Skip to content
Snippets Groups Projects
Select Git revision
  • 934eefb27a0e3c2adddb3ef05ac698078157a628
  • master default protected
  • deploy-components-in-1-job
  • fix-exit-code-dsconfig
  • L2SS-2347-dithering-is-global-setting
  • refactor-control-power-properties
  • update-lcu-rollout-procedure
  • test-pytango-10.0.3
  • deploy-components-parallel
  • L2SS-2407-swap-iers-caltable-monitoring-port
  • L2SS-2357-fix-ruff
  • sync-up-with-meta-pypcc
  • stabilise-landing-page
  • all-stations-lofar2
  • v0.39.7-backports
  • Move-sdptr-to-v1.5.0
  • fix-build-ubuntu
  • tokens-in-env-files
  • fix-build
  • L2SS-2214-deploy-cdb
  • fix-missing-init
  • v0.56.0 protected
  • 0.53.0rc2
  • 0.53.0rc1
  • last-working-mapper-refactor
  • v0.52.9 protected
  • v0.52.8 protected
  • v0.52.7 protected
  • v0.55.5-r2 protected
  • v0.52.8-rc1 protected
  • v0.55.5 protected
  • v0.55.4 protected
  • 0.55.2.dev0
  • 0.55.1.dev0
  • 0.55.0.dev0
  • v0.54.0 protected
  • 0.53.2.dev0
  • 0.53.1.dev0
  • v0.52.3-r2 protected
  • remove-snmp-client
  • v0.52.3 protected
41 results

test_device_observation_field.py

Blame
    • Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    DbInsertionTests.cpp 29.30 KiB 
    /* Copyright (C) : 2014-2019
   European Synchrotron Radiation Facility
   BP 220, Grenoble 38043, FRANCE

   This file is part of libhdb++timescale.

   libhdb++timescale is free software: you can redistribute it and/or modify
   it under the terms of the Lesser GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.

   libhdb++timescale is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the Lesser
   GNU General Public License for more details.

   You should have received a copy of the Lesser GNU General Public License
   along with libhdb++timescale.  If not, see <http://www.gnu.org/licenses/>. */

#include "DbConnection.hpp"
#include "HdbppDefines.hpp"
#include "QueryBuilder.hpp"
#include "TestHelpers.hpp"

#include <benchmark/benchmark.h>
#include <memory>

//=============================================================================
//=============================================================================
void clearTables()
{
    auto conn = make_unique<pqxx::connection>(hdbpp_test::psql_connection::postgres_db::HdbppConnectionString);

    auto traits_array = hdbpp_test::utils::getTraits();

    {
        auto query = string("TRUNCATE ");

        pqxx::work tx {*conn};

        for (auto &traits : traits_array)
        {
            query += hdbpp_internal::pqxx_conn::QueryBuilder::tableName(traits);
            query += ",";
        }

        query += hdbpp_internal::pqxx_conn::schema::ErrTableName + ",";
        query += hdbpp_internal::pqxx_conn::schema::ParamTableName + ",";
        query += hdbpp_internal::pqxx_conn::schema::HistoryEventTableName + ",";
        query += hdbpp_internal::pqxx_conn::schema::HistoryTableName + ",";
        query += hdbpp_internal::pqxx_conn::schema::ConfTableName + " RESTART IDENTITY";

        tx.exec(query);
        tx.commit();
    }
}

//=============================================================================
//=============================================================================
template<Tango::CmdArgType Type, Tango::AttrDataFormat Format, int Size = 0>
void bmAllocateData(benchmark::State &state)
{
    // TEST - Test data allocation time, so we can subtract it from the db write
    // tests
    hdbpp_internal::LogConfigurator::initLogging("test");
    hdbpp_internal::AttributeTraits traits {Tango::READ_WRITE, Format, Type};

    for (auto _ : state)
    {
        for (int i = 0; i < 1000; i++)
            {
            if (Format == Tango::SPECTRUM)
            {
                auto value_r = hdbpp_test::data_gen::generateSpectrumData<Type>(false, Size);
                auto value_w = hdbpp_test::data_gen::generateSpectrumData<Type>(false, Size);
            }
            else
            {
                auto value_r = hdbpp_test::data_gen::generateData<Type>(traits);
                auto value_w = hdbpp_test::data_gen::generateData<Type>(traits);
            }
        }
    }
}

BENCHMARK_TEMPLATE(bmAllocateData, Tango::DEV_BOOLEAN, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmAllocateData, Tango::DEV_SHORT, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmAllocateData, Tango::DEV_LONG, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmAllocateData, Tango::DEV_LONG64, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmAllocateData, Tango::DEV_FLOAT, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmAllocateData, Tango::DEV_DOUBLE, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmAllocateData, Tango::DEV_UCHAR, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmAllocateData, Tango::DEV_USHORT, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmAllocateData, Tango::DEV_ULONG, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmAllocateData, Tango::DEV_ULONG64, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmAllocateData, Tango::DEV_STRING, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmAllocateData, Tango::DEV_STATE, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);

BENCHMARK_TEMPLATE(bmAllocateData, Tango::DEV_BOOLEAN, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmAllocateData, Tango::DEV_SHORT, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmAllocateData, Tango::DEV_LONG, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmAllocateData, Tango::DEV_LONG64, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmAllocateData, Tango::DEV_FLOAT, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmAllocateData, Tango::DEV_DOUBLE, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmAllocateData, Tango::DEV_UCHAR, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmAllocateData, Tango::DEV_USHORT, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmAllocateData, Tango::DEV_ULONG, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmAllocateData, Tango::DEV_ULONG64, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmAllocateData, Tango::DEV_STRING, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmAllocateData, Tango::DEV_STATE, Tango::SCALAR)->Unit(benchmark::kMillisecond);

//=============================================================================
//=============================================================================
template<Tango::CmdArgType Type, Tango::AttrDataFormat Format, int Size = 0>
void bmDbMultipleSQLInsert(benchmark::State &state)
{
    // TEST - Test the write speed when pushing a single event at a time
    // to the database. This version inserts via strings
    hdbpp_internal::LogConfigurator::initLogging("test");
    clearTables();

    hdbpp_internal::AttributeTraits traits {Tango::READ, Format, Type};

    hdbpp_internal::pqxx_conn::DbConnection conn(hdbpp_internal::pqxx_conn::DbConnection::DbStoreMethod::InsertString);

    conn.connect(hdbpp_test::psql_connection::postgres_db::HdbppConnectionString);

    conn.storeAttribute(hdbpp_test::attr_name::TestAttrFinalName,
        hdbpp_test::attr_name::TestAttrCs,
        hdbpp_test::attr_name::TestAttrDomain,
        hdbpp_test::attr_name::TestAttrFamily,
        hdbpp_test::attr_name::TestAttrMember,
        hdbpp_test::attr_name::TestAttrName,
        0,
        traits);

    struct timeval tv
    {};

    for (auto _ : state)
        {
        for (int i = 0; i < 1000; i++)
        {
            gettimeofday(&tv, nullptr);
            double event_time = tv.tv_sec + tv.tv_usec / 1.0e6;

            if (Format == Tango::SPECTRUM)
            {
                conn.storeDataEvent(hdbpp_test::attr_name::TestAttrFinalName,
                    event_time,
                    1,
                    move(hdbpp_test::data_gen::generateSpectrumData<Type>(false, Size)),
                    move(hdbpp_test::data_gen::generateSpectrumData<Type>(false, Size)),
                    traits);
            }
            else
            {
                conn.storeDataEvent(hdbpp_test::attr_name::TestAttrFinalName,
                    event_time,
                    1,
                    move(hdbpp_test::data_gen::generateData<Type>(traits)),
                    move(hdbpp_test::data_gen::generateData<Type>(traits)),
                    traits);
            }
        }
    }

    conn.disconnect();
}

BENCHMARK_TEMPLATE(bmDbMultipleSQLInsert, Tango::DEV_BOOLEAN, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultipleSQLInsert, Tango::DEV_SHORT, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultipleSQLInsert, Tango::DEV_LONG, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultipleSQLInsert, Tango::DEV_LONG64, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultipleSQLInsert, Tango::DEV_FLOAT, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultipleSQLInsert, Tango::DEV_DOUBLE, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultipleSQLInsert, Tango::DEV_UCHAR, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultipleSQLInsert, Tango::DEV_USHORT, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultipleSQLInsert, Tango::DEV_ULONG, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultipleSQLInsert, Tango::DEV_ULONG64, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultipleSQLInsert, Tango::DEV_STRING, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultipleSQLInsert, Tango::DEV_STATE, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);

BENCHMARK_TEMPLATE(bmDbMultipleSQLInsert, Tango::DEV_BOOLEAN, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultipleSQLInsert, Tango::DEV_SHORT, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultipleSQLInsert, Tango::DEV_LONG, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultipleSQLInsert, Tango::DEV_LONG64, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultipleSQLInsert, Tango::DEV_FLOAT, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultipleSQLInsert, Tango::DEV_DOUBLE, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultipleSQLInsert, Tango::DEV_UCHAR, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultipleSQLInsert, Tango::DEV_USHORT, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultipleSQLInsert, Tango::DEV_ULONG, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultipleSQLInsert, Tango::DEV_ULONG64, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultipleSQLInsert, Tango::DEV_STRING, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultipleSQLInsert, Tango::DEV_STATE, Tango::SCALAR)->Unit(benchmark::kMillisecond);

//=============================================================================
//=============================================================================
template<Tango::CmdArgType Type, Tango::AttrDataFormat Format, int Size = 0>
void bmDbMultiplePreparedStatementInsert(benchmark::State &state)
{
    // TEST - Test the write speed when pushing a single event at a time
    // to the database. This version inserts via prepared statements
    hdbpp_internal::LogConfigurator::initLogging("test");
    clearTables();

    hdbpp_internal::AttributeTraits traits {Tango::READ, Format, Type};

    hdbpp_internal::pqxx_conn::DbConnection conn(
        hdbpp_internal::pqxx_conn::DbConnection::DbStoreMethod::PreparedStatement);
    
    conn.connect(hdbpp_test::psql_connection::postgres_db::HdbppConnectionString);

    conn.storeAttribute(hdbpp_test::attr_name::TestAttrFinalName,
        hdbpp_test::attr_name::TestAttrCs,
        hdbpp_test::attr_name::TestAttrDomain,
        hdbpp_test::attr_name::TestAttrFamily,
        hdbpp_test::attr_name::TestAttrMember,
        hdbpp_test::attr_name::TestAttrName,
        0,
        traits);

    struct timeval tv
    {};

    for (auto _ : state)
    {
        for (int i = 0; i < 1000; i++)
        {
            gettimeofday(&tv, nullptr);
            double event_time = tv.tv_sec + tv.tv_usec / 1.0e6;

            if (Format == Tango::SPECTRUM)
            {
                conn.storeDataEvent(hdbpp_test::attr_name::TestAttrFinalName,
                    event_time,
                    1,
                    move(hdbpp_test::data_gen::generateSpectrumData<Type>(false, Size)),
                    move(hdbpp_test::data_gen::generateSpectrumData<Type>(false, Size)),
                    traits);
            }
            else
            {
                conn.storeDataEvent(hdbpp_test::attr_name::TestAttrFinalName,
                    event_time,
                    1,
                    move(hdbpp_test::data_gen::generateData<Type>(traits)),
                    move(hdbpp_test::data_gen::generateData<Type>(traits)),
                    traits);
            }
        }
    }

    conn.disconnect();
}

BENCHMARK_TEMPLATE(bmDbMultiplePreparedStatementInsert, Tango::DEV_BOOLEAN, Tango::SPECTRUM, 512)
    ->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultiplePreparedStatementInsert, Tango::DEV_SHORT, Tango::SPECTRUM, 512)
    ->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultiplePreparedStatementInsert, Tango::DEV_LONG, Tango::SPECTRUM, 512)
    ->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultiplePreparedStatementInsert, Tango::DEV_LONG64, Tango::SPECTRUM, 512)
    ->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultiplePreparedStatementInsert, Tango::DEV_FLOAT, Tango::SPECTRUM, 512)
    ->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultiplePreparedStatementInsert, Tango::DEV_DOUBLE, Tango::SPECTRUM, 512)
    ->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultiplePreparedStatementInsert, Tango::DEV_UCHAR, Tango::SPECTRUM, 512)
    ->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultiplePreparedStatementInsert, Tango::DEV_USHORT, Tango::SPECTRUM, 512)
    ->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultiplePreparedStatementInsert, Tango::DEV_ULONG, Tango::SPECTRUM, 512)
    ->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultiplePreparedStatementInsert, Tango::DEV_ULONG64, Tango::SPECTRUM, 512)
    ->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultiplePreparedStatementInsert, Tango::DEV_STRING, Tango::SPECTRUM, 512)
    ->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultiplePreparedStatementInsert, Tango::DEV_STATE, Tango::SPECTRUM, 512)
    ->Unit(benchmark::kMillisecond);
    
BENCHMARK_TEMPLATE(bmDbMultiplePreparedStatementInsert, Tango::DEV_BOOLEAN, Tango::SCALAR)
    ->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultiplePreparedStatementInsert, Tango::DEV_SHORT, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultiplePreparedStatementInsert, Tango::DEV_LONG, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultiplePreparedStatementInsert, Tango::DEV_LONG64, Tango::SCALAR)
    ->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultiplePreparedStatementInsert, Tango::DEV_FLOAT, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultiplePreparedStatementInsert, Tango::DEV_DOUBLE, Tango::SCALAR)
    ->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultiplePreparedStatementInsert, Tango::DEV_UCHAR, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultiplePreparedStatementInsert, Tango::DEV_USHORT, Tango::SCALAR)
    ->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultiplePreparedStatementInsert, Tango::DEV_ULONG, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultiplePreparedStatementInsert, Tango::DEV_ULONG64, Tango::SCALAR)
    ->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultiplePreparedStatementInsert, Tango::DEV_STRING, Tango::SCALAR)
    ->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbMultiplePreparedStatementInsert, Tango::DEV_STATE, Tango::SCALAR)->Unit(benchmark::kMillisecond);

//=============================================================================
//=============================================================================
template<Tango::CmdArgType Type, Tango::AttrDataFormat Format, int Size = 0>
void bmDbBatchedInsert(benchmark::State &state)
{
    // TEST - Test the write speed when pushing a multiple events at once to
    // the db
    hdbpp_internal::LogConfigurator::initLogging("test");
    clearTables();

    hdbpp_internal::AttributeTraits traits {Tango::READ, Format, Type};

    hdbpp_internal::pqxx_conn::DbConnection conn(
        hdbpp_internal::pqxx_conn::DbConnection::DbStoreMethod::PreparedStatement);

    conn.connect(hdbpp_test::psql_connection::postgres_db::HdbppConnectionString);
    conn.buffer(true);

    conn.storeAttribute(hdbpp_test::attr_name::TestAttrFinalName,
        hdbpp_test::attr_name::TestAttrCs,
        hdbpp_test::attr_name::TestAttrDomain,
        hdbpp_test::attr_name::TestAttrFamily,
        hdbpp_test::attr_name::TestAttrMember,
        hdbpp_test::attr_name::TestAttrName,
        0,
        traits);

    struct timeval tv
    {};

    for (auto _ : state)
    {
        for (int i = 0; i < 1000; i++)
        {
            gettimeofday(&tv, nullptr);
            double event_time = tv.tv_sec + tv.tv_usec / 1.0e6;

            if (Format == Tango::SPECTRUM)
            {
                conn.storeDataEvent(hdbpp_test::attr_name::TestAttrFinalName,
                    event_time,
                    1,
                    move(hdbpp_test::data_gen::generateSpectrumData<Type>(false, Size)),
                    move(hdbpp_test::data_gen::generateSpectrumData<Type>(false, Size)),
                    traits);
            }
            else
            {
                conn.storeDataEvent(hdbpp_test::attr_name::TestAttrFinalName,
                    event_time,
                        1,
                    move(hdbpp_test::data_gen::generateData<Type>(traits)),
                    move(hdbpp_test::data_gen::generateData<Type>(traits)),
                    traits);
            }
        }

        conn.flush();
    }

    conn.buffer(false);
    conn.disconnect();
}

BENCHMARK_TEMPLATE(bmDbBatchedInsert, Tango::DEV_BOOLEAN, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbBatchedInsert, Tango::DEV_SHORT, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbBatchedInsert, Tango::DEV_LONG, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbBatchedInsert, Tango::DEV_LONG64, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbBatchedInsert, Tango::DEV_FLOAT, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbBatchedInsert, Tango::DEV_DOUBLE, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbBatchedInsert, Tango::DEV_UCHAR, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbBatchedInsert, Tango::DEV_USHORT, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbBatchedInsert, Tango::DEV_ULONG, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbBatchedInsert, Tango::DEV_ULONG64, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbBatchedInsert, Tango::DEV_STRING, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbBatchedInsert, Tango::DEV_STATE, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);

BENCHMARK_TEMPLATE(bmDbBatchedInsert, Tango::DEV_BOOLEAN, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbBatchedInsert, Tango::DEV_SHORT, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbBatchedInsert, Tango::DEV_LONG, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbBatchedInsert, Tango::DEV_LONG64, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbBatchedInsert, Tango::DEV_FLOAT, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbBatchedInsert, Tango::DEV_DOUBLE, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbBatchedInsert, Tango::DEV_UCHAR, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbBatchedInsert, Tango::DEV_USHORT, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbBatchedInsert, Tango::DEV_ULONG, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbBatchedInsert, Tango::DEV_ULONG64, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbBatchedInsert, Tango::DEV_STRING, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbBatchedInsert, Tango::DEV_STATE, Tango::SCALAR)->Unit(benchmark::kMillisecond);

//=============================================================================
//=============================================================================
template<Tango::CmdArgType Type, Tango::AttrDataFormat Format, int Size = 0>
void bmDbSingleSQLInsert(benchmark::State &state)
{
    // TEST - Test the write speed when pushing a single event via sql
    hdbpp_internal::LogConfigurator::initLogging("test");
    clearTables();

    hdbpp_internal::AttributeTraits traits {Tango::READ, Format, Type};

    hdbpp_internal::pqxx_conn::DbConnection conn(hdbpp_internal::pqxx_conn::DbConnection::DbStoreMethod::InsertString);

    conn.connect(hdbpp_test::psql_connection::postgres_db::HdbppConnectionString);

    conn.storeAttribute(hdbpp_test::attr_name::TestAttrFinalName,
        hdbpp_test::attr_name::TestAttrCs,
        hdbpp_test::attr_name::TestAttrDomain,
        hdbpp_test::attr_name::TestAttrFamily,
        hdbpp_test::attr_name::TestAttrMember,
        hdbpp_test::attr_name::TestAttrName,
        0,
        traits);

    struct timeval tv
    {};

    for (auto _ : state)
    {
        gettimeofday(&tv, nullptr);
            double event_time = tv.tv_sec + tv.tv_usec / 1.0e6;

        if (Format == Tango::SPECTRUM)
        {
            conn.storeDataEvent(hdbpp_test::attr_name::TestAttrFinalName,
                event_time,
                1,
                move(hdbpp_test::data_gen::generateSpectrumData<Type>(false, Size)),
                move(hdbpp_test::data_gen::generateSpectrumData<Type>(false, Size)),
                traits);
        }
        else
        {
            conn.storeDataEvent(hdbpp_test::attr_name::TestAttrFinalName,
                event_time,
                1,
                move(hdbpp_test::data_gen::generateData<Type>(traits)),
                move(hdbpp_test::data_gen::generateData<Type>(traits)),
                traits);
        }
    }

    conn.buffer(false);
    conn.disconnect();
}

BENCHMARK_TEMPLATE(bmDbSingleSQLInsert, Tango::DEV_BOOLEAN, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSingleSQLInsert, Tango::DEV_SHORT, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSingleSQLInsert, Tango::DEV_LONG, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSingleSQLInsert, Tango::DEV_LONG64, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSingleSQLInsert, Tango::DEV_FLOAT, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSingleSQLInsert, Tango::DEV_DOUBLE, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSingleSQLInsert, Tango::DEV_UCHAR, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSingleSQLInsert, Tango::DEV_USHORT, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSingleSQLInsert, Tango::DEV_ULONG, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSingleSQLInsert, Tango::DEV_ULONG64, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSingleSQLInsert, Tango::DEV_STRING, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSingleSQLInsert, Tango::DEV_STATE, Tango::SPECTRUM, 512)->Unit(benchmark::kMillisecond);

BENCHMARK_TEMPLATE(bmDbSingleSQLInsert, Tango::DEV_BOOLEAN, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSingleSQLInsert, Tango::DEV_SHORT, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSingleSQLInsert, Tango::DEV_LONG, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSingleSQLInsert, Tango::DEV_LONG64, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSingleSQLInsert, Tango::DEV_FLOAT, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSingleSQLInsert, Tango::DEV_DOUBLE, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSingleSQLInsert, Tango::DEV_UCHAR, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSingleSQLInsert, Tango::DEV_USHORT, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSingleSQLInsert, Tango::DEV_ULONG, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSingleSQLInsert, Tango::DEV_ULONG64, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSingleSQLInsert, Tango::DEV_STRING, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSingleSQLInsert, Tango::DEV_STATE, Tango::SCALAR)->Unit(benchmark::kMillisecond);

//=============================================================================
//=============================================================================
template<Tango::CmdArgType Type, Tango::AttrDataFormat Format, int Size = 0>
void bmDbSinglePreparedStatementInsert(benchmark::State &state)
{
    // TEST - Test the write speed when pushing a single event via sql
    hdbpp_internal::LogConfigurator::initLogging("test");
    clearTables();

    hdbpp_internal::AttributeTraits traits {Tango::READ, Format, Type};

    hdbpp_internal::pqxx_conn::DbConnection conn(
        hdbpp_internal::pqxx_conn::DbConnection::DbStoreMethod::PreparedStatement);

    conn.connect(hdbpp_test::psql_connection::postgres_db::HdbppConnectionString);

    conn.storeAttribute(hdbpp_test::attr_name::TestAttrFinalName,
        hdbpp_test::attr_name::TestAttrCs,
            hdbpp_test::attr_name::TestAttrDomain,
        hdbpp_test::attr_name::TestAttrFamily,
        hdbpp_test::attr_name::TestAttrMember,
        hdbpp_test::attr_name::TestAttrName,
        0,
        traits);

    struct timeval tv
    {};

    for (auto _ : state)
    {
        gettimeofday(&tv, nullptr);
        double event_time = tv.tv_sec + tv.tv_usec / 1.0e6;

        if (Format == Tango::SPECTRUM)
        {
            conn.storeDataEvent(hdbpp_test::attr_name::TestAttrFinalName,
                event_time,
                1,
                move(hdbpp_test::data_gen::generateSpectrumData<Type>(false, Size)),
                move(hdbpp_test::data_gen::generateSpectrumData<Type>(false, Size)),
                traits);
        }
        else
        {
            conn.storeDataEvent(hdbpp_test::attr_name::TestAttrFinalName,
                event_time,
                1,
                move(hdbpp_test::data_gen::generateData<Type>(traits)),
                move(hdbpp_test::data_gen::generateData<Type>(traits)),
                traits);
        }
    }

    conn.buffer(false);
    conn.disconnect();
}

BENCHMARK_TEMPLATE(bmDbSinglePreparedStatementInsert, Tango::DEV_BOOLEAN, Tango::SPECTRUM, 512)
    ->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSinglePreparedStatementInsert, Tango::DEV_SHORT, Tango::SPECTRUM, 512)
    ->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSinglePreparedStatementInsert, Tango::DEV_LONG, Tango::SPECTRUM, 512)
    ->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSinglePreparedStatementInsert, Tango::DEV_LONG64, Tango::SPECTRUM, 512)
    ->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSinglePreparedStatementInsert, Tango::DEV_FLOAT, Tango::SPECTRUM, 512)
    ->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSinglePreparedStatementInsert, Tango::DEV_DOUBLE, Tango::SPECTRUM, 512)
    ->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSinglePreparedStatementInsert, Tango::DEV_UCHAR, Tango::SPECTRUM, 512)
    ->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSinglePreparedStatementInsert, Tango::DEV_USHORT, Tango::SPECTRUM, 512)
    ->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSinglePreparedStatementInsert, Tango::DEV_ULONG, Tango::SPECTRUM, 512)
    ->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSinglePreparedStatementInsert, Tango::DEV_ULONG64, Tango::SPECTRUM, 512)
    ->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSinglePreparedStatementInsert, Tango::DEV_STRING, Tango::SPECTRUM, 512)
    ->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSinglePreparedStatementInsert, Tango::DEV_STATE, Tango::SPECTRUM, 512)
    ->Unit(benchmark::kMillisecond);

BENCHMARK_TEMPLATE(bmDbSinglePreparedStatementInsert, Tango::DEV_BOOLEAN, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSinglePreparedStatementInsert, Tango::DEV_SHORT, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSinglePreparedStatementInsert, Tango::DEV_LONG, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSinglePreparedStatementInsert, Tango::DEV_LONG64, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSinglePreparedStatementInsert, Tango::DEV_FLOAT, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSinglePreparedStatementInsert, Tango::DEV_DOUBLE, Tango::SCALAR)->Unit(benchmark::kMillisecond);
    BENCHMARK_TEMPLATE(bmDbSinglePreparedStatementInsert, Tango::DEV_UCHAR, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSinglePreparedStatementInsert, Tango::DEV_USHORT, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSinglePreparedStatementInsert, Tango::DEV_ULONG, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSinglePreparedStatementInsert, Tango::DEV_ULONG64, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSinglePreparedStatementInsert, Tango::DEV_STRING, Tango::SCALAR)->Unit(benchmark::kMillisecond);
BENCHMARK_TEMPLATE(bmDbSinglePreparedStatementInsert, Tango::DEV_STATE, Tango::SCALAR)->Unit(benchmark::kMillisecond);