oks_ls_data.cxx

Go to the documentation of this file.

//
// DUNE DAQ modification notice:
// This file has been modified from the original ATLAS oks_utils source for the DUNE DAQ project.
// Fork baseline commit: c2e7dfc7 (2022-03-30).
// Renamed since fork: yes (from src/bin/oks_ls_data.cpp to apps/oks_ls_data.cxx).
//
 
#include <list>
 
#include "CoralBase/Exception.h"
#include "CoralKernel/Context.h"
#include <CoralBase/Attribute.h>
#include <CoralBase/AttributeList.h>
#include <CoralBase/AttributeSpecification.h>
 
#include "RelationalAccess/ConnectionService.h"
#include "RelationalAccess/ISessionProxy.h"
#include "RelationalAccess/ITransaction.h"
#include <RelationalAccess/ICursor.h>
#include <RelationalAccess/IQuery.h>
#include <RelationalAccess/ISchema.h>
#include <RelationalAccess/ITable.h>
#include <RelationalAccess/ITransaction.h>
#include <RelationalAccess/SchemaException.h>
 
#include <iostream>
#include <stdexcept>
#include <stdlib.h>
#include <unistd.h>
 
#include "ers/ers.hpp"
 
#include "oks/ral.hpp"
#include "oks/tz.hpp"

 
// The struct describes table's row with 5 items, separator and fill chars.
// It is used to print separator line, title row and application parameters
 
struct TableRow
{
  char m_fill;
  char m_separator;
  std::string m_items[7];
  TableRow(const char fill, const char separator)
    : m_fill(fill)
    , m_separator(separator)
  {
    ;
  }
  TableRow(const char fill,
           const char separator,
           int sv,
           int dv,
           int bv,
           const std::string& release,
           const std::string& date,
           const std::string& user,
           const std::string& host,
           const std::string& description,
           long num_of_obj = 0,
           long num_of_attr = 0,
           long num_of_rel = 0)
    : m_fill(fill)
    , m_separator(separator)
  {
    if (sv || dv || bv) {
      std::ostringstream s;
      s << sv << '.' << dv;
      if (bv != dv)
        s << '.' << bv;
      m_items[0] = s.str();
    }
    m_items[1] = release;
    m_items[2] = date;
    m_items[3] = user;
    m_items[4] = host;
    if (num_of_obj || num_of_attr || num_of_rel) {
      std::ostringstream s2;
      s2 << num_of_obj << ':' << num_of_attr << ':' << num_of_rel;
      m_items[5] = s2.str();
    }
    m_items[6] = description;
  }
  TableRow(const char fill,
           const char separator,
           const std::string& s1,
           const std::string& s2,
           const std::string& s3,
           const std::string& s4,
           const std::string& s5,
           const std::string& s6,
           const std::string& s7)
    : m_fill(fill)
    , m_separator(separator)
  {
    m_items[0] = s1;
    m_items[1] = s2;
    m_items[2] = s3;
    m_items[3] = s4;
    m_items[4] = s5;
    m_items[5] = s6;
    m_items[6] = s7;
  }
};

 
static void
usage()
{
  std::cout
    << "usage: oks_ls_data\n"
       "   -c | --connect-string connect_string\n"
       "   -w | --working-schema schema_name\n"
       "   [-l | --list-releases]\n"
       "   [-s | --schema-version schema_version]\n"
       "   [-b | --base-data-only]\n"
       "   [-z | --show-size]\n"
       "   [-u | --show-usage]\n"
       "   [-d | --show-description]\n"
       "   [-t | --sorted-by parameters]\n"
       "   [-r | --release release_name]\n"
       "   [-e | --user user_name_pattern]\n"
       "   [-o | --host hostname_pattern]\n"
       "   [-p | --partition partition_name_pattern]\n"
       "   [-S | --archived-since timestamp]\n"
       "   [-T | --archived-till timestamp]\n"
       "   [-Z | --time-zone name]\n"
       "   [-v | --verbose-level verbosity_level]\n"
       "   [-h | --help]\n"
       "\n"
       "Options/Arguments:\n"
       "   -c connect_string    database connection string\n"
       "   -w schema_name       name of working schema\n"
       "   -l                   list releases\n"
       "   -s schema_version    print out data of this particular version (0 = HEAD version)\n"
       "   -b                   print out base data versions only\n"
       "   -z                   print size of version (i.e. number of relational rows to store it)\n"
       "   -u                   show who, when, where and how used given version\n"
       "   -d                   show description\n"
       "   -t parameters        sort output by several columns; the parameters may contain the following\n"
       "                        items (where first symbol is for ascending and second for descending order):\n"
       "                          v | V - sort by versions (run-number for usage [-u option]);\n"
       "                          t | T - sort by time;\n"
       "                          u | U - sort by user names;\n"
       "                          h | H - sort by hostnames;\n"
       "                          p | P - sort by partition names (i.e. by descriptions);\n"
       //    "                          s | S - sort by sizes of archive, requires -u option.\n" // disabled because of
       //    Oracle bug
       "   -r release_name      show configurations for given release name\n"
       "   -e user_name_pattern show configurations for user names satisfying pattern (see syntax description below)\n"
       "   -o hostname_pattern  show configurations for hostnames satisfying pattern (see syntax description below)\n"
       "   -p partition_pattern show configurations or usage for partition names satisfying pattern (see syntax "
       "description below)\n"
       "   -S since_timestamp   show configurations archived or used since given moment (see timestamp format "
       "description below)\n"
       "   -T till_timestamp    show configurations archived before given moment (see timestamp format description "
       "below)\n"
       "   -Z name              time zone name (run \"-Z list-regions\" to see all supported time zones)\n"
       "   -v verbosity_level   set verbose output level (0 - silent, 1 - normal, 2 - extended, 3 - debug, ...)\n"
       "   -h                   print this message\n"
       "\n"
       "Description:\n"
       "   The utility prints out details of oks data versions archived in relational database.\n"
       "   The Version is shown as sv.dv[.bv], where:\n"
       "    * sv = schema version;\n"
       "    * dv = data version;\n"
       "    * bv = base version (optional, only appears for incremental data versions).\n"
       "   The Size (numbers of relational rows) is reported in form x:y:z, where the:\n"
       "    * x = number of new[/deleted/updated] objects;\n"
       "    * y = number of new[/deleted/updated] attribute values;\n"
       "    * z = number of new[/deleted/updated] relationship values.\n"
       "   By default the input timestamps are expected and the results are printed in UTC.\n"
       "   To use specific local time run program with -Z option (e.g. \"-Z \'Europe/Zurich\'\" for CERN local time).\n"
       "   The timestamps to be provided in ISO 8601 format: \"YYYY-MM-DD HH:MM:SS\".\n"
       "   The allowed wildcard characters used to select by user, host and partition names are:\n"
       "    % (i.e. percent symbol)     - any string of zero or more characters;\n"
       "    _ (i.e. underscore symbol)  - any single character.\n\n";
  //    "    [ ] - any single character within the specified range ([a.f]) or set ([abcdef]);\n"
  //    "    [^] - any single character not within the specified range ([^a.d]) or set ([^abcd]).\n\n";
}
 
static void
no_param(const char* s)
{
  std::cerr << "ERROR: no parameter for " << s << " provided\n\n";
}
 
static bool
has_a_pattern(const std::string& s)
{
  return ((s.find("%") != std::string::npos) || (s.find("_") != std::string::npos) ||
              (s.find("[") != std::string::npos && s.find("]") != std::string::npos)
            ? true
            : false);
}
 
int
main(int argc, char* argv[])
{
 
  // parse and check command line
 
  int verbose_level = 1;
  std::string connect_string;
  std::string working_schema;
  int schema_version = -1;            // -1 -> ALL, 0 -> HEAD, >0 -> exact version
  bool ls_base_versions_only = false; // -b
  bool ls_get_size = false;           // -z
  bool ls_usage = false;              // -u
  bool ls_description = false;        // -d
  bool list_db = false;               // -l
  std::string release;
  std::string user;
  std::string host;
  std::string partition;
  std::string acrhived_since;
  std::string acrhived_till;
  std::string sorted_by;
  const char* tmp_acrhived_since(0);
  const char* tmp_acrhived_till(0);
  const char* tz(0);
  boost::local_time::time_zone_ptr tz_ptr;
 
  for (int i = 1; i < argc; i++) {
    const char* cp = argv[i];
 
    if (!strcmp(cp, "-h") || !strcmp(cp, "--help")) {
      usage();
      return (EXIT_SUCCESS);
    } else if (!strcmp(cp, "-b") || !strcmp(cp, "--base-data-only")) {
      ls_base_versions_only = true;
    } else if (!strcmp(cp, "-l") || !strcmp(cp, "--list-releases")) {
      list_db = true;
    } else if (!strcmp(cp, "-z") || !strcmp(cp, "--show-size")) {
      ls_get_size = true;
    } else if (!strcmp(cp, "-u") || !strcmp(cp, "--show-usage")) {
      ls_usage = true;
    } else if (!strcmp(cp, "-d") || !strcmp(cp, "--show-description")) {
      ls_description = true;
    }
 
    else if (!strcmp(cp, "-t") || !strcmp(cp, "--sorted-by")) {
      if (++i == argc) {
        no_param(cp);
        return (EXIT_FAILURE);
      } else {
        sorted_by = argv[i];
      }
    } else if (!strcmp(cp, "-r") || !strcmp(cp, "--release")) {
      if (++i == argc) {
        no_param(cp);
        return (EXIT_FAILURE);
      } else {
        release = argv[i];
      }
    } else if (!strcmp(cp, "-e") || !strcmp(cp, "--user")) {
      if (++i == argc) {
        no_param(cp);
        return (EXIT_FAILURE);
      } else {
        user = argv[i];
      }
    } else if (!strcmp(cp, "-o") || !strcmp(cp, "--host")) {
      if (++i == argc) {
        no_param(cp);
        return (EXIT_FAILURE);
      } else {
        host = argv[i];
      }
    } else if (!strcmp(cp, "-p") || !strcmp(cp, "--partition")) {
      if (++i == argc) {
        no_param(cp);
        return (EXIT_FAILURE);
      } else {
        partition = argv[i];
      }
    } else if (!strcmp(cp, "-v") || !strcmp(cp, "--verbose-level")) {
      if (++i == argc) {
        no_param(cp);
        return (EXIT_FAILURE);
      } else {
        verbose_level = atoi(argv[i]);
      }
    } else if (!strcmp(cp, "-s") || !strcmp(cp, "--schema-version")) {
      if (++i == argc) {
        no_param(cp);
        return (1);
      } else {
        schema_version = atoi(argv[i]);
      }
    } else if (!strcmp(cp, "-c") || !strcmp(cp, "--connect-string")) {
      if (++i == argc) {
        no_param(cp);
        return (1);
      } else {
        connect_string = argv[i];
      }
    } else if (!strcmp(cp, "-w") || !strcmp(cp, "--working-schema")) {
      if (++i == argc) {
        no_param(cp);
        return (1);
      } else {
        working_schema = argv[i];
      }
    } else if (!strcmp(cp, "-S") || !strcmp(cp, "--archived-since")) {
      if (++i == argc) {
        no_param(cp);
        return 1;
      } else {
        tmp_acrhived_since = argv[i];
      }
    } else if (!strcmp(cp, "-T") || !strcmp(cp, "--archived-till")) {
      if (++i == argc) {
        no_param(cp);
        return 1;
      } else {
        tmp_acrhived_till = argv[i];
      }
    } else if (!strcmp(cp, "-Z") || !strcmp(cp, "--time-zone")) {
      if (++i == argc) {
        no_param(cp);
        return 1;
      } else {
        tz = argv[i];
      }
    } else {
      std::cerr << "ERROR: Unexpected parameter: \"" << cp << "\"\n\n";
      usage();
      return (EXIT_FAILURE);
    }
  }
 
  if (tz) {
    try {
      oks::tz::DB tz_db;
 
      if (!strcmp(tz, "list-regions")) {
        for (auto& i : tz_db.get_regions()) {
          std::cout << i << std::endl;
        }
        return 0;
      }
 
      tz_ptr = tz_db.get_tz_ptr(tz);
    } catch (const std::exception& ex) {
      std::cerr << "ERROR: time-zone db access failed: " << ex.what() << std::endl;
      return 2;
    }
  }
 
  if (connect_string.empty()) {
    std::cerr << "ERROR: the connect string is required\n";
    usage();
    return EXIT_FAILURE;
  }
 
  if (working_schema.empty()) {
    std::cerr << "ERROR: the working schema is required\n";
    usage();
    return EXIT_FAILURE;
  }
 
  try {
    if (tmp_acrhived_since) {
      acrhived_since =
        oks::tz::posix_time_2_iso_string(oks::tz::str_2_posix_time(tmp_acrhived_since, tz_ptr, "archived-since"));
    }
 
    if (tmp_acrhived_till) {
      acrhived_till =
        oks::tz::posix_time_2_iso_string(oks::tz::str_2_posix_time(tmp_acrhived_till, tz_ptr, "archived-till"));
    }
  } catch (const std::exception& ex) {
    std::cerr << "ERROR: " << ex.what() << std::endl;
    return 2;
  }
 
  try {
 
    std::unique_ptr<coral::ConnectionService> connection;
 
    {
      std::unique_ptr<coral::ISessionProxy> session(
        oks::ral::start_coral_session(connect_string, coral::ReadOnly, connection, verbose_level));
 
      if (list_db) {
        coral::ITable& schema_table = session->schema(working_schema).tableHandle("OKSSCHEMA");
        std::unique_ptr<coral::IQuery> query(schema_table.newQuery());
        query->setRowCacheSize(10);
        query->setDistinct();
        query->addToOutputList("RELEASE");
        coral::ICursor& cursor = query->execute();
 
        std::set<std::string> names;
 
        while (cursor.next()) {
          names.insert(cursor.currentRow().begin()->data<std::string>());
        }
 
        std::cout << "Found configuration archives for " << names.size() << " releases:\n";
 
        for (std::set<std::string>::const_iterator i = names.begin(); i != names.end(); ++i) {
          std::cout << " - \'" << *i << '\'' << std::endl;
        }
      } else {
        if (schema_version == 0) {
          schema_version =
            oks::ral::get_head_schema_version(session.get(), working_schema, release.c_str(), verbose_level, "  ");
          if (schema_version == 0) {
            throw std::runtime_error("Cannot get HEAD schema version.");
          }
        }
 
        coral::ITable& archive_table = session->schema(working_schema).tableHandle("OKSARCHIVE");
 
        std::list<std::string> conditions_list;
        coral::AttributeList conditions;
 
        std::unique_ptr<coral::IQuery> query(session->schema(working_schema).newQuery());
        query->setRowCacheSize(1000);
 
        query->addToOutputList("A.SCHEMAVERSION");
        query->addToOutputList("A.BASEVERSION");
        query->addToOutputList("A.VERSION");
        query->addToOutputList("B.RELEASE");
        query->addToOutputList("A.TIME");
        query->addToOutputList("A.CREATEDBY");
        query->addToOutputList("A.HOST");
 
        if (ls_description) {
          query->addToOutputList("A.DESCRIPTION");
        }
 
        coral::IQueryDefinition& subQuery1 = query->defineSubQuery("A");
        subQuery1.addToTableList("OKSDATA");
        query->addToTableList("A");
 
        coral::IQueryDefinition& subQuery2 = query->defineSubQuery("B");
        subQuery2.addToTableList("OKSSCHEMA");
        query->addToTableList("B");
 
        conditions_list.push_back("A.SCHEMAVERSION = B.VERSION");
 
        /*if(ls_get_size) {
          struct {
            const char * var;
            const char * table;
          } ts[] = {
              {"X", "OKSOBJECT"  },
            {"Y", "OKSDATAVAL" },
            {"Z", "OKSDATAREL" }
          };
 
          for(unsigned int i = 0; i < 1 ; ++i) {
            std::string p = std::string(ts[i].var) + ".S";
 
            query->addToOutputList(p);
            query->addToTableList( ts[i].var );
            query->defineOutputType( p, "long");
 
            coral::IQueryDefinition& subQuery = query->defineSubQuery( ts[i].var );
            subQuery.addToOutputList( "count(*)", "S" );
            subQuery.addToOutputList( "SCHEMAVERSION" );
            subQuery.addToOutputList( "DATAVERSION");
            subQuery.addToTableList( ts[i].table );
            subQuery.setCondition( "SCHEMAVERSION > 0 group by SCHEMAVERSION, DATAVERSION" , coral::AttributeList());
 
            conditions_list.push_back(std::string("A.SCHEMAVERSION = ") + ts[i].var + ".SCHEMAVERSION");
            conditions_list.push_back(std::string("A.VERSION = ") + ts[i].var + ".DATAVERSION");
          }
        }*/
 
        if (schema_version != -1) {
          conditions.extend<int>("ver");
          conditions["ver"].data<int>() = schema_version;
 
          if (ls_base_versions_only) {
            conditions_list.push_back("A.SCHEMAVERSION = :ver AND A.VERSION = A.BASEVERSION");
          } else {
            conditions_list.push_back("A.SCHEMAVERSION = :ver");
          }
        } else if (ls_base_versions_only) {
          conditions_list.push_back("A.VERSION = A.BASEVERSION");
        }
 
        if (!release.empty()) {
          conditions.extend<std::string>("rel");
          conditions["rel"].data<std::string>() = release;
          conditions_list.push_back("B.RELEASE = :rel");
        }
 
        if (!partition.empty()) {
          if (!ls_usage) {
            if (ls_description == false) {
              throw std::runtime_error("cannot search by partition without \"-d\" or \"-u\" command line option");
            }
            conditions.extend<std::string>("prt1");
            conditions["prt1"].data<std::string>() = std::string("%partition ") + partition + '%';
            conditions_list.push_back("A.DESCRIPTION like :prt1");
          }
        }
 
        if (!acrhived_since.empty()) {
          conditions.extend<std::string>("ars");
          conditions["ars"].data<std::string>() = acrhived_since;
          if (ls_usage) {
            query->setDistinct();
            coral::IQueryDefinition& subQuery3 = query->defineSubQuery("C");
            subQuery3.addToTableList("OKSARCHIVE");
            query->addToTableList("C");
            std::string condition("C.TIME >= :ars AND A.SCHEMAVERSION = C.SCHEMAVERSION AND A.VERSION = C.DATAVERSION");
            if (!partition.empty()) {
              conditions.extend<std::string>("prt2");
              conditions["prt2"].data<std::string>() = partition;
              condition += (has_a_pattern(partition) ? " AND C.PARTITION like :prt2" : " AND C.PARTITION = :prt2");
            }
            conditions_list.push_back(condition);
          } else {
            conditions_list.push_back("A.TIME >= :ars");
          }
        }
 
        if (!acrhived_till.empty()) {
          conditions.extend<std::string>("art");
          conditions["art"].data<std::string>() = acrhived_till;
          conditions_list.push_back("A.TIME <= :art");
        }
 
        if (!user.empty()) {
          conditions.extend<std::string>("usr");
          conditions["usr"].data<std::string>() = user;
          conditions_list.push_back(has_a_pattern(user) ? "A.CREATEDBY like :usr" : "A.CREATEDBY = :usr");
        }
 
        if (!host.empty()) {
          conditions.extend<std::string>("hst");
          conditions["hst"].data<std::string>() = host;
          conditions_list.push_back(has_a_pattern(host) ? "A.HOST like :hst" : "A.HOST = :hst");
        }
 
        if (!sorted_by.empty()) {
          for (const char* p = sorted_by.c_str(); *p != 0; ++p) {
            if (ls_description == false && (*p == 'p' || *p == 'P')) {
              throw std::runtime_error("cannot sort by partition without \"-d\" command line option");
            }
 
            switch (*p) {
              case 'v':
                query->addToOrderList("A.SCHEMAVERSION");
                query->addToOrderList("A.VERSION");
                break;
              case 'V':
                query->addToOrderList("A.SCHEMAVERSION DESC");
                query->addToOrderList("A.VERSION DESC");
                break;
              case 't':
                query->addToOrderList("A.TIME");
                break;
              case 'T':
                query->addToOrderList("A.TIME DESC");
                break;
              case 'u':
                query->addToOrderList("A.CREATEDBY");
                break;
              case 'U':
                query->addToOrderList("A.CREATEDBY DESC");
                break;
              case 'h':
                query->addToOrderList("A.HOST");
                break;
              case 'H':
                query->addToOrderList("A.HOST DESC");
                break;
              case 'p':
                query->addToOrderList("A.DESCRIPTION");
                break;
              case 'P':
                query->addToOrderList("A.DESCRIPTION DESC");
                break;
              // case 's': query->addToOrderList("X.S"); break;
              // case 'S': query->addToOrderList("X.S DESC"); break;
              default:
                std::stringstream text;
                text << "ERROR: wrong value \'" << *p << "\' in the command line parameter: \"--sorted-by\" or \"-t\"";
                throw std::runtime_error(text.str().c_str());
            }
          }
        }
 
        std::string conditions_str;
 
        for (std::list<std::string>::const_iterator i = conditions_list.begin(); i != conditions_list.end(); ++i) {
          if (i != conditions_list.begin())
            conditions_str += " AND ";
          conditions_str += *i;
        }
 
        query->setCondition(conditions_str, conditions);
 
        coral::ICursor& cursor = query->execute();
 
        std::vector<TableRow> rows;
 
        // fill the table
 
        rows.push_back(TableRow('=', '='));
        rows.push_back(TableRow(' ',
                                '|',
                                "Version",
                                "Release",
                                (tz_ptr ? "Date (local time)" : "Date (UTC)"),
                                "User",
                                "Host",
                                "Size",
                                "Description"));
        rows.push_back(TableRow('=', '='));
 
        struct
        {
          long num;
          coral::ITable& table;
        } nums[] = { { 0, session->schema(working_schema).tableHandle("OKSOBJECT") },
                     { 0, session->schema(working_schema).tableHandle("OKSDATAVAL") },
                     { 0, session->schema(working_schema).tableHandle("OKSDATAREL") } };
 
        while (cursor.next()) {
          const coral::AttributeList& row = cursor.currentRow();
 
          std::string time, host, user;
          oks::ral::get_time_host_user(row, time, host, user, tz_ptr, "A.");
          std::string description;
          if (ls_description && !row["A.DESCRIPTION"].isNull())
            description = row["A.DESCRIPTION"].data<std::string>();
          std::string r;
          if (!row["B.RELEASE"].isNull())
            r = row["B.RELEASE"].data<std::string>();
          int sv = row["A.SCHEMAVERSION"].data<int>();
          int dv = row["A.VERSION"].data<int>();
          nums[0].num = nums[1].num = nums[2].num = 0;
 
          if (ls_get_size) {
            coral::AttributeList sizes_query_conditions;
            sizes_query_conditions.extend<int>("sv");
            sizes_query_conditions["sv"].data<int>() = sv;
            sizes_query_conditions.extend<int>("dv");
            sizes_query_conditions["dv"].data<int>() = dv;
 
            for (unsigned int i = 0; i < 3; ++i) {
              std::unique_ptr<coral::IQuery> query(nums[i].table.newQuery());
              query->setRowCacheSize(1);
              query->addToOutputList("COUNT(*)");
              query->defineOutputType("COUNT(*)", "long");
              query->setCondition("SCHEMAVERSION = :sv AND DATAVERSION = :dv", sizes_query_conditions);
 
              coral::ICursor& c = query->execute();
 
              if (c.next()) {
                nums[i].num = (int)c.currentRow().begin()->data<long>();
              }
            }
          }
 
          rows.push_back(TableRow(' ',
                                  '|',
                                  sv,
                                  dv,
                                  row["A.BASEVERSION"].data<int>(),
                                  r,
                                  time,
                                  user,
                                  host,
                                  description,
                                  nums[0].num,
                                  nums[1].num,
                                  nums[2].num));
 
          if (ls_usage) {
            std::unique_ptr<coral::IQuery> query(archive_table.newQuery());
            coral::AttributeList archive_query_conditions;
            archive_query_conditions.extend<int>("sv");
            archive_query_conditions["sv"].data<int>() = sv;
            archive_query_conditions.extend<int>("dv");
            archive_query_conditions["dv"].data<int>() = dv;
            query->setRowCacheSize(10);
            query->addToOutputList("TIME");
            query->addToOutputList("PARTITION");
            query->addToOutputList("CREATEDBY");
            query->addToOutputList("HOST");
            query->addToOutputList("RUNNUMBER");
 
            if (!sorted_by.empty()) {
              for (const char* p = sorted_by.c_str(); *p != 0; ++p) {
 
                switch (*p) {
                  case 'v':
                    query->addToOrderList("RUNNUMBER");
                    break;
                  case 'V':
                    query->addToOrderList("RUNNUMBER DESC");
                    break;
                  case 't':
                    query->addToOrderList("TIME");
                    break;
                  case 'T':
                    query->addToOrderList("TIME DESC");
                    break;
                  case 'u':
                    query->addToOrderList("CREATEDBY");
                    break;
                  case 'U':
                    query->addToOrderList("CREATEDBY DESC");
                    break;
                  case 'h':
                    query->addToOrderList("HOST");
                    break;
                  case 'H':
                    query->addToOrderList("HOST DESC");
                    break;
                  case 'p':
                    query->addToOrderList("PARTITION");
                    break;
                  case 'P':
                    query->addToOrderList("PARTITION DESC");
                    break;
                }
              }
            }
 
            std::string condition("SCHEMAVERSION = :sv AND DATAVERSION = :dv");
 
            if (!acrhived_since.empty()) {
              archive_query_conditions.extend<std::string>("ars");
              archive_query_conditions["ars"].data<std::string>() = acrhived_since;
              condition += " AND TIME >= :ars";
            }
 
            if (!acrhived_till.empty()) {
              archive_query_conditions.extend<std::string>("art");
              archive_query_conditions["art"].data<std::string>() = acrhived_till;
              condition += " AND TIME <= :art";
            }
 
            if (!partition.empty()) {
              archive_query_conditions.extend<std::string>("prt");
              archive_query_conditions["prt"].data<std::string>() = partition;
              condition += (has_a_pattern(partition) ? " AND PARTITION like :prt" : " AND PARTITION = :prt");
            }
 
            query->setCondition(condition, archive_query_conditions);
 
            coral::ICursor& c = query->execute();
 
            while (c.next()) {
              const coral::AttributeList& ar_row = c.currentRow();
              std::string ar_time, ar_host, ar_user;
              oks::ral::get_time_host_user(ar_row, ar_time, ar_host, ar_user, tz_ptr);
              std::string p;
              if (!ar_row["PARTITION"].isNull())
                p = ar_row["PARTITION"].data<std::string>();
 
              std::ostringstream s;
              s << "partition: " << p << " run: " << ar_row["RUNNUMBER"].data<int>();
 
              rows.push_back(TableRow(' ', '|', 0, 0, 0, r, ar_time, ar_user, ar_host, s.str()));
            }
          }
        }
 
        rows.push_back(TableRow('=', '='));
 
        // detect columns widths
 
        unsigned short cw[] = { 1, 1, 1, 1, 1, 1, 1 };
        {
          for (auto& i : rows) {
            for (unsigned short j = 0; j < sizeof(cw) / sizeof(unsigned short); ++j) {
              unsigned short len = i.m_items[j].size();
              if (len > cw[j])
                cw[j] = len;
            }
          }
        }
 
        // print table
 
        {
          bool align_left[] = { false, true, true, true, true, false, true };
 
          for (std::vector<TableRow>::const_iterator i = rows.begin(); i != rows.end(); ++i) {
            std::cout.fill((*i).m_fill);
            for (unsigned short j = 0; j < sizeof(cw) / sizeof(unsigned short); ++j) {
              std::cout << (*i).m_separator << (*i).m_fill;
              std::cout.setf((align_left[j] ? std::ios::left : std::ios::right), std::ios::adjustfield);
              std::cout.width(cw[j]);
              std::cout << (*i).m_items[j] << (*i).m_fill;
            }
            std::cout << (*i).m_separator << std::endl;
          }
        }
      }
 
      session->transaction().commit();
 
      VerboseMsg2("Ending user session..."); // delete session by unique_ptr<>
    }
 
    VerboseMsg2("Disconnecting..."); // delete connection by unique_ptr<>
  }
 
  catch (coral::Exception& e) {
    std::cerr << "CORAL exception: " << e.what() << std::endl;
    return 1;
  }
 
  catch (std::exception& e) {
    std::cerr << "Standard C++ exception : " << e.what() << std::endl;
    return 2;
  }
 
  catch (...) {
    std::cerr << "Exception caught (...)" << std::endl;
    return 3;
  }
 
  VerboseMsg2("Exiting...");
 
  return 0;
}