history_odbc.cxx

Go to the documentation of this file.

/********************************************************************\
 
  Name:         history_odbc.cxx
  Created by:   Konstantin Olchanski
 
  Contents:     Interface class for writing MIDAS history data to SQL databases throught the ODBC interface layer
 
\********************************************************************/
 
#include "midas.h"
#include "msystem.h"
 
#include <vector>
#include <string>
 
//         MIDAS includes             //
 
#include "midas.h"
#include "history.h"
#include "mstrlcpy.h"
 
//           helper stuff             //
 
#define FREE(x) { if (x) free(x); (x) = NULL; }
 
// Definitions extracted from midas.c //
 
/********************************************************************/
/* data type sizes */
static const int tid_size[] = {
   0,                           /* tid == 0 not defined                               */
   1,                           /* TID_UINT8     unsigned byte         0       255    */
   1,                           /* TID_INT8      signed byte         -128      127    */
   1,                           /* TID_CHAR      single character      0       255    */
   2,                           /* TID_UINT16    two bytes             0      65535   */
   2,                           /* TID_INT16     signed word        -32768    32767   */
   4,                           /* TID_UINT32    four bytes            0      2^32-1  */
   4,                           /* TID_INT32     signed dword        -2^31    2^31-1  */
   4,                           /* TID_BOOL      four bytes bool       0        1     */
   4,                           /* TID_FLOAT     4 Byte float format                  */
   8,                           /* TID_DOUBLE    8 Byte float format                  */
   4,                           /* TID_BITFIELD  32 Bits Bitfield   00000... 11111... */
   0,                           /* TID_STRING    zero terminated string               */
   0,                           /* TID_ARRAY     variable length array of unkown type */
   0,                           /* TID_STRUCT    C structure                          */
   0,                           /* TID_KEY       key in online database               */
   0,                           /* TID_LINK      link in online database              */
   8,                           /* TID_INT64     8 bytes int          -2^63   2^63-1  */
   8                            /* TID_UINT64    8 bytes unsigned int  0      2^64-1  */
};
 
/* data type names */
static const char *tid_name[] = {
   "NULL",
   "UINT8",
   "INT8",
   "CHAR",
   "UINT16",
   "INT16",
   "UINT32",
   "INT32",
   "BOOL",
   "FLOAT",
   "DOUBLE",
   "BITFIELD",
   "STRING",
   "ARRAY",
   "STRUCT",
   "KEY",
   "LINK",
   "INT64",
   "UINT64"
};
 
// SQL types
#ifdef HAVE_ODBC
static const char *sql_type_pgsql[] = {
   "xxxINVALIDxxxNULL", // TID_NULL
   "SMALLINT",  // MYSQL "TINYINT SIGNED", // TID_BYTE
   "SMALLINT",  // MYSQL "TINYINT UNSIGNED",  // TID_SBYTE
   "CHAR(1)",   // TID_CHAR
   "SMALLINT",  // MYSQL "SMALLINT UNSIGNED ", // TID_WORD
   "SMALLINT",  // MYSQL "SMALLINT SIGNED ", // TID_SHORT
   "INTEGER",   // MYSQL "INT UNSIGNED ", // TID_DWORD
   "INTEGER",   // MYSQL "INT SIGNED ", // TID_INT
   "BOOL",      // TID_BOOL
   "FLOAT(53)", // MYSQL "DOUBLE" TID_FLOAT
   "FLOAT(53)", // MYSQL "DOUBLE" TID_DOUBLE
   "INTEGER",   // MYSQL "INT UNSIGNED", // TID_BITFIELD
   "VARCHAR",   // TID_STRING
   "xxxINVALIDxxxARRAY",
   "xxxINVALIDxxxSTRUCT",
   "xxxINVALIDxxxKEY",
   "xxxINVALIDxxxLINK"
};
#endif
 
static const char *sql_type_mysql[] = {
   "xxxINVALIDxxxNULL", // TID_NULL
   "tinyint unsigned",  // TID_UINT8
   "tinyint",           // TID_INT8
   "char",              // TID_CHAR
   "smallint unsigned", // TID_UINT16
   "smallint",          // TID_INT16
   "integer unsigned",  // TID_UINT32
   "integer",           // TID_INT32
   "tinyint",           // TID_BOOL
   "float",             // TID_FLOAT
   "double",            // TID_DOUBLE
   "integer unsigned",  // TID_BITFIELD
   "VARCHAR",           // TID_STRING
   "xxxINVALIDxxxARRAY",
   "xxxINVALIDxxxSTRUCT",
   "xxxINVALIDxxxKEY",
   "xxxINVALIDxxxLINK"
};
 
//    Handling of data types          //
 
static const char **sql_type = NULL;
 
static const char* midasTypeName(int tid)
{
   assert(tid>=0);
   assert(tid<15);
   return tid_name[tid];
}
 
static const char* midas2sqlType(int tid)
{
   assert(tid>=0);
   assert(tid<15);
   return sql_type[tid];
}
 
static int sql2midasType(const char* name)
{
   for (int tid=0; tid<15; tid++)
      if (strcasecmp(name, sql_type[tid])==0)
         return tid;
   printf("sql2midasType: Cannot convert SQL data type \'%s\' to a MIDAS data type!\n", name);
   return 0;
}
 
static bool isCompatible(int tid, const char* sqlType)
{
#if 0
   printf("compare types midas \'%s\'=\'%s\' and sql \'%s\'\n", midasTypeName(tid), midas2sqlType(tid), sqlType);
#endif
   
   if (sql2midasType(sqlType) == tid)
      return true;
 
   if (strcasecmp(midas2sqlType(tid), sqlType) == 0)
      return true;
 
   // permit writing FLOAT into DOUBLE
   if (tid==TID_FLOAT && strcmp(sqlType, "double")==0)
      return true;
 
   // T2K quirk!
   // permit writing BYTE into signed tinyint
   if (tid==TID_UINT8 && strcmp(sqlType, "tinyint")==0)
      return true;
 
   // T2K quirk!
   // permit writing WORD into signed tinyint
   if (tid==TID_UINT16 && strcmp(sqlType, "tinyint")==0)
      return true;
 
   return false;
}
 
//    Base class for access to SQL functions   //
 
class SqlBase
{
public:
  virtual int SetDebug(int debug) = 0;
  virtual int Connect(const char* dsn = 0) = 0;
  virtual int Disconnect() = 0;
  virtual bool IsConnected() = 0;
  virtual int Exec(const char* sql) = 0;
  virtual int GetNumRows() = 0;
  virtual int GetNumColumns() = 0;
  virtual int Fetch() = 0;
  virtual int Done() = 0;
  virtual int ListTables(std::vector<std::string> *plist) = 0;
  virtual int ListColumns(const char* table, std::vector<std::string> *plist) = 0;
  virtual const char* GetColumn(int icol) = 0;
  virtual ~SqlBase() { }; // virtual dtor
};
 
//   SqlDebug: for debugging: write all SQL commands to stdout   //
 
class SqlDebug: public SqlBase
{
public:
   FILE *fp;
   bool fIsConnected;
   int fDebug;
 
public:
 
   SqlDebug() // ctor
   {
      fp = NULL;
      fIsConnected = false;
   }
 
   ~SqlDebug() // dtor
   {
      if (fp)
         fclose(fp);
      fp = NULL;
   }
 
   int SetDebug(int debug)
   {
      int old_debug = fDebug;
      fDebug = debug;
      return old_debug;
   }
 
   int Connect(const char* filename = NULL)
   {
      if (!filename)
         filename = "/dev/fd/1";
      fp = fopen(filename, "w");
      assert(fp);
      sql_type = sql_type_mysql;
      fIsConnected = true;
      return DB_SUCCESS;
   }
 
   int Exec(const char* sql)
   {
      fprintf(fp, "%s\n", sql);
      return DB_SUCCESS;
   }
 
   int Disconnect()
   {
      // do nothing
      fIsConnected = false;
      return DB_SUCCESS;
   }
 
   bool IsConnected()
   {
      return fIsConnected;
   }
 
   int GetNumRows() { return DB_SUCCESS; }
   int GetNumColumns() { return DB_SUCCESS; }
   int Fetch() { return DB_NO_MORE_SUBKEYS; }
   int Done() { return DB_SUCCESS; }
   int ListTables(std::vector<std::string> *plist) { return DB_SUCCESS; };
   int ListColumns(const char* table, std::vector<std::string> *plist) { return DB_SUCCESS; };
   const char* GetColumn(int icol) { return NULL; };
};
 
#ifdef HAVE_ODBC
 
//          ODBC includes             //
 
// MIDAS defines collide with ODBC
 
#define DWORD DWORD_xxx
#define BOOL  BOOL_xxx
 
#include <sql.h>
#include <sqlext.h>
#include <sqltypes.h>
 
//   SqlODBC: SQL access through ODBC   //
 
class SqlODBC: public SqlBase
{
public:
   bool fIsConnected;
 
   std::string fDSN;
 
   int fDebug;
 
   SQLHENV  fEnv;
   SQLHDBC  fDB;
   SQLHSTMT fStmt;
 
   SqlODBC(); // ctor
   ~SqlODBC(); // dtor
 
   int SetDebug(int debug)
   {
      int old_debug = fDebug;
      fDebug = debug;
      return old_debug;
   }
 
   int Connect(const char* dsn);
   int Disconnect();
   bool IsConnected();
 
   int ListTables(std::vector<std::string> *plist);
   int ListColumns(const char* table_name, std::vector<std::string> *plist);
 
   int Exec(const char* sql);
 
   int GetNumRows();
   int GetNumColumns();
   int Fetch();
   const char* GetColumn(int icol);
   int Done();
 
protected:
   void ReportErrors(const char* from, const char* sqlfunc, int status);
   int DecodeError();
};
 
SqlODBC::SqlODBC() // ctor
{
   fIsConnected = false;
   fDebug = 0;
}
 
SqlODBC::~SqlODBC() // dtor
{
   Disconnect();
}
 
int SqlODBC::Connect(const char* dsn)
{
   if (fIsConnected)
      Disconnect();
 
   fDSN = dsn;
 
   int status = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &fEnv);
 
   if (!SQL_SUCCEEDED(status)) {
      cm_msg(MERROR, "SqlODBC::Connect", "SQLAllocHandle(SQL_HANDLE_ENV) error %d", status);
      return DB_FILE_ERROR;
   }
 
   status = SQLSetEnvAttr(fEnv,
                          SQL_ATTR_ODBC_VERSION,
                          (void*)SQL_OV_ODBC2,
                          0);
   if (!SQL_SUCCEEDED(status)) {
      cm_msg(MERROR, "SqlODBC::Connect", "SQLSetEnvAttr() error %d", status);
      SQLFreeHandle(SQL_HANDLE_ENV, fEnv);
      return DB_FILE_ERROR;
   }
 
   status = SQLAllocHandle(SQL_HANDLE_DBC, fEnv, &fDB);
   if (!SQL_SUCCEEDED(status)) {
      cm_msg(MERROR, "SqlODBC::Connect", "SQLAllocHandle(SQL_HANDLE_DBC) error %d", status);
      SQLFreeHandle(SQL_HANDLE_ENV, fEnv);
      return DB_FILE_ERROR;
   }
 
   SQLSetConnectAttr(fDB, SQL_LOGIN_TIMEOUT, (SQLPOINTER *)5, 0);
 
   if (0) {
      // connect to PgSQL database
 
      sql_type = sql_type_pgsql;
      status = SQLConnect(fDB, (SQLCHAR*) dsn, SQL_NTS,
                          (SQLCHAR*) "xxx", SQL_NTS,
                          (SQLCHAR*) "", SQL_NTS);
   }
 
   if (1) {
      // connect to MySQL database
 
      sql_type = sql_type_mysql;
      status = SQLConnect(fDB, (SQLCHAR*) dsn, SQL_NTS,
                          (SQLCHAR*) NULL, SQL_NTS,
                          (SQLCHAR*) NULL, SQL_NTS);
   }
 
   if ((status != SQL_SUCCESS) && (status != SQL_SUCCESS_WITH_INFO)) {
      SQLINTEGER    V_OD_err;
      SQLSMALLINT   V_OD_mlen;
      SQLCHAR       V_OD_stat[10]; // Status SQL
      SQLCHAR       V_OD_msg[200];
 
      SQLGetDiagRec(SQL_HANDLE_DBC, fDB, 1, V_OD_stat, &V_OD_err, V_OD_msg, 100, &V_OD_mlen);
      cm_msg(MERROR, "SqlODBC::Connect", "SQLConnect() error %d, %s (%d)", status, V_OD_msg,V_OD_err);
      SQLFreeHandle(SQL_HANDLE_ENV, fEnv);
      return DB_FILE_ERROR;
   }
 
   SQLAllocHandle(SQL_HANDLE_STMT, fDB, &fStmt);
 
   if (fDebug)
      cm_msg(MINFO, "SqlODBC::Connect", "Connected to ODBC database DSN \'%s\'", dsn);
 
   fIsConnected = true;
 
   return DB_SUCCESS;
}
 
int SqlODBC::Disconnect()
{
   if (!fIsConnected)
      return DB_SUCCESS;
 
   SQLDisconnect(fDB);
 
   SQLFreeHandle(SQL_HANDLE_DBC,  fDB);
   SQLFreeHandle(SQL_HANDLE_STMT, fStmt);
   SQLFreeHandle(SQL_HANDLE_ENV,  fEnv);
 
   fIsConnected = false;
 
   return DB_SUCCESS;
}
 
bool SqlODBC::IsConnected()
{
   return fIsConnected;
}
 
void SqlODBC::ReportErrors(const char* from, const char* sqlfunc, int status)
{
   if (fDebug)
      printf("%s: %s error %d\n", from, sqlfunc, status);
 
   for (int i=1; ; i++) {
      SQLCHAR      state[10]; // Status SQL
      SQLINTEGER      error;
      SQLCHAR              message[1024];
      SQLSMALLINT     mlen;
 
      status = SQLGetDiagRec(SQL_HANDLE_STMT,
                             fStmt,
                             i,
                             state,
                             &error,
                             message,
                             sizeof(message),
                             &mlen);
 
      if (status == SQL_NO_DATA)
         break;
 
      if (!SQL_SUCCEEDED(status)) {
         cm_msg(MERROR, "SqlODBC::ReportErrors", "SQLGetDiagRec() error %d", status);
         break;
      }
 
      // Catch error "MySQL has gone away" and turn it into a warning. The program should be trying to reconnect immediately
      // and will produce an error if it fails
      if (1 || (error == 2006) ) {
         if (fDebug)
            printf("%s: %s warning: state: \'%s\', message: \'%s\', native error: %d\n", from, sqlfunc, state, message, (int)error);
         cm_msg(MINFO, from, "%s warning: state: \'%s\', message: \'%s\', native error: %d", sqlfunc, state, message, (int)error);
      } else if (1 || ((error != 1060) && (error != 1050))) {
         if (fDebug)
            printf("%s: %s error: state: \'%s\', message: \'%s\', native error: %d\n", from, sqlfunc, state, message, (int)error);
         cm_msg(MERROR, from, "%s error: state: \'%s\', message: \'%s\', native error: %d", sqlfunc, state, message, (int)error);
      }
   }
}
 
int SqlODBC::DecodeError()
{
   // returns:
   // DB_SUCCESS
   // DB_NO_KEY
   // DB_KEY_EXIST
 
   for (int i=1; ; i++) {
      SQLCHAR      state[10]; // Status SQL
      SQLINTEGER      error;
      SQLCHAR              message[1024];
      SQLSMALLINT     mlen;
 
      error = 0;
 
      int status = SQLGetDiagRec(SQL_HANDLE_STMT,
                                 fStmt,
                                 i,
                                 state,
                                 &error,
                                 message,
                                 sizeof(message),
                                 &mlen);
 
      if (status == SQL_NO_DATA)
         return DB_SUCCESS;
 
      if (error==1146)
         return DB_NO_KEY;
 
      if (error==1050)
         return DB_KEY_EXIST;
   }
}
 
int SqlODBC::ListTables(std::vector<std::string> *plist)
{
   if (!fIsConnected)
      return DB_FILE_ERROR;
 
   for (int i=0; i<2; i++) {
      if (fDebug)
         printf("SqlODBC::ListTables!\n");
 
      /* Retrieve a list of tables */
      int status = SQLTables(fStmt, NULL, 0, NULL, 0, NULL, 0, (SQLCHAR*)"TABLE", SQL_NTS);
 
      if (SQL_SUCCEEDED(status))
         break;
 
      if (fDebug)
         printf("SqlODBC::ListTables: SQLTables() error %d\n", status);
 
      ReportErrors("SqlODBC::ListTables", "SQLTables()", status);
 
      status = DecodeError();
 
      //if (status == DB_NO_KEY)
      //   return status;
      //
      //if (status == DB_KEY_EXIST)
      //  return status;
 
      cm_msg(MINFO, "SqlODBC::ListTables", "Reconnecting to ODBC database DSN \'%s\'", fDSN.c_str());
 
      // try to reconnect
      std::string dsn = fDSN;
      Disconnect();
      status = Connect(dsn.c_str());
 
      if (!fIsConnected) {
         cm_msg(MERROR, "SqlODBC::ListTables", "Cannot reconnect to ODBC database DSN \'%s\', status %d. Database is down?", fDSN.c_str(), status);
         return DB_FILE_ERROR;
      }
 
      cm_msg(MINFO, "SqlODBC::ListTables", "Reconnected to ODBC database DSN \'%s\'", fDSN.c_str());
   }
 
   int ncols = GetNumColumns();
   int nrows = GetNumRows();
 
   if (ncols <= 0 || nrows <= 0) {
      cm_msg(MERROR, "SqlODBC::ListTables", "Error: SQLTables() returned unexpected number of columns %d or number of rows %d", ncols, nrows);
   }
 
   int row = 0;
   while (1) {
      int status = Fetch();
      if (status != DB_SUCCESS)
         break;
 
      if (0) {
         printf("row %d: ", row);
         for (int i=1; i<=ncols; i++) {
            const char* s = GetColumn(i);
            printf("[%s]", s);
         }
         printf("\n");
         row++;
      }
 
      plist->push_back(GetColumn(3));
   }
 
   Done();
 
   return DB_SUCCESS;
}
 
int SqlODBC::ListColumns(const char* table, std::vector<std::string> *plist)
{
   if (!fIsConnected)
      return DB_FILE_ERROR;
 
   for (int i=0; i<2; i++) {
      if (fDebug)
         printf("SqlODBC::ListColumns for table \'%s\'\n", table);
 
      /* Retrieve a list of columns */
      int status = SQLColumns(fStmt, NULL, 0, NULL, 0, (SQLCHAR*)table, SQL_NTS, NULL, 0);
 
      if (SQL_SUCCEEDED(status))
         break;
 
      if (fDebug)
         printf("SqlODBC::ListColumns: SQLColumns(%s) error %d\n", table, status);
 
      ReportErrors("SqlODBC::ListColumns", "SQLColumns()", status);
 
      status = DecodeError();
 
      //if (status == DB_NO_KEY)
      //   return status;
      //
      //if (status == DB_KEY_EXIST)
      //  return status;
 
      cm_msg(MINFO, "SqlODBC::ListColumns", "Reconnecting to ODBC database DSN \'%s\'", fDSN.c_str());
 
      // try to reconnect
      std::string dsn = fDSN;
      Disconnect();
      status = Connect(dsn.c_str());
 
      if (!fIsConnected) {
         cm_msg(MERROR, "SqlODBC::ListColumns", "Cannot reconnect to ODBC database DSN \'%s\', status %d. Database is down?", fDSN.c_str(), status);
         return DB_FILE_ERROR;
      }
 
      cm_msg(MINFO, "SqlODBC::ListColumns", "Reconnected to ODBC database DSN \'%s\'", fDSN.c_str());
   }
 
   int ncols = GetNumColumns();
   int nrows = GetNumRows(); // nrows seems to be always "-1"
 
   if (ncols <= 0 /*|| nrows <= 0*/) {
      cm_msg(MERROR, "SqlODBC::ListColumns", "Error: SQLColumns(\'%s\') returned unexpected number of columns %d or number of rows %d", table, ncols, nrows);
   }
 
   //printf("get columns [%s]: status %d, ncols %d, nrows %d\n", table, status, ncols, nrows);
 
   int row = 0;
   while (1) {
      int status = Fetch();
      if (status != DB_SUCCESS)
         break;
 
      if (0) {
         printf("row %d: ", row);
         for (int i=1; i<=ncols; i++) {
            const char* s = GetColumn(i);
            printf("[%s]", s);
         }
         printf("\n");
         row++;
      }
 
      plist->push_back(GetColumn(4)); // column name
      plist->push_back(GetColumn(6)); // column type
   }
 
   Done();
 
   return DB_SUCCESS;
}
 
int SqlODBC::Exec(const char* sql)
{
   // return values:
   // DB_SUCCESS
   // DB_FILE_ERROR: not connected
   // DB_NO_KEY: "table not found"
 
   if (!fIsConnected)
      return DB_FILE_ERROR;
 
   int status;
 
   for (int i=0; i<2; i++) {
      if (fDebug)
         printf("SqlODBC::Exec: %s\n", sql);
 
      status = SQLExecDirect(fStmt,(SQLCHAR*)sql,SQL_NTS);
 
      if (SQL_SUCCEEDED(status)) {
         return DB_SUCCESS;
      }
 
      if (fDebug)
         printf("SqlODBC::Exec: SQLExecDirect() error %d: SQL command: \"%s\"\n", status, sql);
 
      ReportErrors("SqlODBC::Exec", "SQLExecDirect()", status);
 
      status = DecodeError();
 
      if (status == DB_NO_KEY)
         return status;
 
      if (status == DB_KEY_EXIST)
         return status;
 
      cm_msg(MINFO, "SqlODBC::Exec", "Reconnecting to ODBC database DSN \'%s\'", fDSN.c_str());
 
      // try to reconnect
      std::string dsn = fDSN;
      Disconnect();
      status = Connect(dsn.c_str());
 
      if (!fIsConnected) {
         cm_msg(MERROR, "SqlODBC::Exec", "Cannot reconnect to ODBC database DSN \'%s\', status %d. Database is down?", fDSN.c_str(), status);
         return DB_FILE_ERROR;
      }
 
      cm_msg(MINFO, "SqlODBC::Exec", "Reconnected to ODBC database DSN \'%s\'", fDSN.c_str());
   }
 
   return DB_SUCCESS;
}
 
int SqlODBC::GetNumRows()
{
   SQLLEN nrows = 0;
   /* How many rows are there */
   int status = SQLRowCount(fStmt, &nrows);
   if (!SQL_SUCCEEDED(status)) {
      ReportErrors("SqlODBC::GetNumRow", "SQLRowCount()", status);
      return -1;
   }
   return nrows;
}
 
int SqlODBC::GetNumColumns()
{
   SQLSMALLINT ncols = 0;
   /* How many columns are there */
   int status = SQLNumResultCols(fStmt, &ncols);
   if (!SQL_SUCCEEDED(status)) {
      ReportErrors("SqlODBC::GetNumColumns", "SQLNumResultCols()", status);
      return -1;
   }
   return ncols;
}
 
int SqlODBC::Fetch()
{
   int status = SQLFetch(fStmt);
 
   if (status == SQL_NO_DATA)
      return DB_NO_MORE_SUBKEYS;
 
   if (!SQL_SUCCEEDED(status)) {
      ReportErrors("SqlODBC::Fetch", "SQLFetch()", status);
      return DB_FILE_ERROR;
   }
 
   return DB_SUCCESS;
}
 
int SqlODBC::Done()
{
   int status = SQLCloseCursor(fStmt);
   if (!SQL_SUCCEEDED(status)) {
      ReportErrors("SqlODBC::Done", "SQLCloseCursor()", status);
      return DB_FILE_ERROR;
   }
   return DB_SUCCESS;
}
 
const char* SqlODBC::GetColumn(int icol)
{
  static char buf[1024];
  SQLLEN indicator;
  int status = SQLGetData(fStmt, icol, SQL_C_CHAR, buf, sizeof(buf), &indicator);
 
  if (!SQL_SUCCEEDED(status)) {
    return NULL;
  }
 
  if (indicator == SQL_NULL_DATA)
    return NULL;
 
  return buf;
}
 
#endif
 
//        Done with SQL stuff           //
 
//  Data structures to keep track of Events and Tags  //
 
struct Tag
{
   std::string column_name;
   int   offset;
   TAG   tag;
   bool  create;
};
 
struct Event
{
   std::string event_name;
   std::string table_name;
   std::vector<Tag> tags;
   bool  active;
 
   Event() // ctor
   {
      active = false;
   }
 
   ~Event() // dtor
   {
      active = false;
   }
};
 
static void PrintTags(int ntags, const TAG tags[])
{
   for (int i=0; i<ntags; i++)
      printf("tag %d: %s %s[%d]\n", i, midasTypeName(tags[i].type), tags[i].name, tags[i].n_data);
}
 
int WriteEvent(SqlBase* sql, Event *e, time_t t, const char*buf, int size)
{
   //printf("event %d, time %s", rec.event_id, ctime(&t));
 
   int n  = e->tags.size();
 
   std::string tags;
   std::string values;
 
   //if (n>0)
   //  printf(" %s", ctime(&t));
 
   for (int i=0; i<n; i++) {
      const Tag*t = &e->tags[i];
 
      if (t) {
         int offset = t->offset;
         void* ptr = (void*)(buf+offset);
 
         int arraySize = t->tag.n_data;
 
         for (int j=0; j<arraySize; j++) {
            tags   += ", ";
            values += ", ";
 
            if (arraySize <= 1)
               tags += t->column_name;
            else {
               tags += t->column_name;
               char s[256];
               sprintf(s,"_%d", j);
               tags += s;
            }
 
            char s[1024];
 
            switch (t->tag.type) {
            default:
               sprintf(s, "unknownType%d", t->tag.type);
               break;
            case 1: /* BYTE */
               sprintf(s, "%u",((unsigned char*)ptr)[j]);
               break;
            case 2: /* SBYTE */
               sprintf(s, "%d",((signed char*)ptr)[j]);
               break;
            case 3: /* CHAR */
               sprintf(s, "\'%c\'",((char*)ptr)[j]);
               break;
            case 4: /* WORD */
               sprintf(s, "%u",((unsigned short*)ptr)[j]);
               break;
            case 5: /* SHORT */
               sprintf(s, "%d",((signed short*)ptr)[j]);
               break;
            case 6: /* DWORD */
               sprintf(s, "%u",((unsigned int*)ptr)[j]);
               break;
            case 7: /* INT */
               sprintf(s, "%d",((int*)ptr)[j]);
               break;
            case 8: /* BOOL */
               sprintf(s, "%u",((unsigned int*)ptr)[j]);
               break;
            case 9: /* FLOAT */
               sprintf(s, "\'%.8g\'",((float*)ptr)[j]);
               break;
            case 10: /* DOUBLE */
               sprintf(s, "\'%.16g\'",((double*)ptr)[j]);
                    break;
            }
 
            values += s;
         }
      }
   }
 
   // 2001-02-16 20:38:40.1
   struct tm tms;
   localtime_r(&t, &tms); // somebody must call tzset() before this
   char s[1024];
   strftime(s,sizeof(s)-1,"%Y-%m-%d %H:%M:%S.0",&tms);
 
   char sss[102400];
   sprintf(sss, "INSERT INTO %s (_t_time, _i_time%s) VALUES (\'%s\', \'%d\'%s);",
           e->table_name.c_str(),
           tags.c_str(),
           s,
           (int)t,
           values.c_str());
 
   int status = sql->Exec(sss);
 
   if (status != DB_SUCCESS) {
      return status;
   }
 
   return HS_SUCCESS;
}
 
// convert MIDAS names to SQL names
 
static std::string MidasNameToSqlName(const char* s)
{
   std::string out;
 
   for (int i=0; s[i]!=0; i++) {
      char c = s[i];
      if (isalpha(c) || isdigit(c))
         out += tolower(c);
      else
         out += '_';
   }
 
   return out;
}
 
struct IndexEntryTag
{
   std::string tag_name;
   std::string column_name;
   int timestamp;
};
 
struct IndexEntry
{
   std::string event_name;
   std::string table_name;
   int timestamp;
   std::vector<IndexEntryTag> tags;
   std::vector<TAG> tags_cache;
};
 
static std::vector<IndexEntry*> gHistoryIndex;
 
#if 0
static void PrintIndex()
{
   for (unsigned i=0; i<gHistoryIndex.size(); i++) {
      IndexEntry *e = gHistoryIndex[i];
 
      printf("entry %d: [%s] [%s], time %d, tags\n", i, e->event_name.c_str(), e->table_name.c_str(), e->timestamp);
 
      for (unsigned j=0; j<e->tags.size(); j++)
         printf("  tag %d: [%s] [%s], time %d\n", j, e->tags[j].tag_name.c_str(), e->tags[j].column_name.c_str(), e->tags[j].timestamp);
   }
}
#endif
 
static IndexEntry* FindIndexByTableName(const char* table_name)
{
   for (unsigned i=0; i<gHistoryIndex.size(); i++)
      if (equal_ustring(gHistoryIndex[i]->table_name.c_str(), table_name)) {
         return gHistoryIndex[i];
      }
   return NULL;
}
 
static IndexEntry* FindIndexByEventName(const char* event_name)
{
   for (unsigned i=0; i<gHistoryIndex.size(); i++)
      if (equal_ustring(gHistoryIndex[i]->event_name.c_str(), event_name)) {
         return gHistoryIndex[i];
      }
   return NULL;
}
 
static IndexEntryTag* FindIndexByTagName(IndexEntry* ie, const char* tag_name)
{
   for (unsigned i=0; i<ie->tags.size(); i++)
      if (equal_ustring(ie->tags[i].tag_name.c_str(), tag_name)) {
         return &ie->tags[i];
      }
   return NULL;
}
 
static IndexEntryTag* FindIndexByColumnName(IndexEntry* ie, const char* column_name)
{
   for (unsigned i=0; i<ie->tags.size(); i++)
      if (equal_ustring(ie->tags[i].column_name.c_str(), column_name)) {
         return &ie->tags[i];
      }
   return NULL;
}
 
static int gHaveIndex = true;
static int gHaveIndexAll = false;
 
static int gTrace = 0;
 
static int ReadIndex(SqlBase* sql, const char* event_name)
{
   if (gTrace)
      printf("ReadIndex [%s]\n", event_name);
 
   if (!gHaveIndex)
      return HS_FILE_ERROR;
 
   if (gHaveIndexAll)
      return HS_SUCCESS;
 
   if (gTrace)
      printf("ReadIndex: reading index for event [%s]\n", event_name);
 
   //event_name = NULL;
 
   char cmd[256];
 
   if (event_name)
      sprintf(cmd, "SELECT event_name, table_name, tag_name, column_name, itimestamp FROM _history_index where event_name=\'%s\';", event_name);
   else
      sprintf(cmd, "SELECT event_name, table_name, tag_name, column_name, itimestamp FROM _history_index;");
 
   int status = sql->Exec(cmd);
 
   if (status == DB_NO_KEY) {
      gHaveIndex = false;
      return HS_FILE_ERROR;
   }
 
   if (gTrace) {
      printf("ReadIndex: event %s, Read status %d, nrows: %d\n",
             event_name,
             status,
             sql->GetNumRows());
   }
 
   if (status != SUCCESS)
      return HS_FILE_ERROR;
 
   if (sql->GetNumRows() == 0) {
      sql->Done();
      return HS_FILE_ERROR;
   }
 
   int nrows = sql->GetNumRows();
   int ncols = sql->GetNumColumns();
 
   if (nrows == 0)
      return HS_SUCCESS;
 
   if (gTrace)
      printf("ReadIndex: event %s, nrows: %d, ncols: %d\n",
             event_name,
             nrows, ncols);
 
   if (nrows < 0)
      return HS_FILE_ERROR;
 
   if (ncols < 1)
      return HS_FILE_ERROR;
 
   /* Loop through the rows in the result-set */
   while (1) {
      status = sql->Fetch();
      if (status != DB_SUCCESS)
         break;
 
      std::string xevent_name  = sql->GetColumn(1);
 
      const char* p = sql->GetColumn(2);
      if (p) { // table declaration
         std::string xtable_name  = p;
         std::string xtimestamp   = sql->GetColumn(5);
         int timestamp = atoi(xtimestamp.c_str());
 
         IndexEntry* ie = FindIndexByEventName(xevent_name.c_str());
         if (!ie) {
            ie = new IndexEntry;
            gHistoryIndex.push_back(ie);
            ie->timestamp = timestamp - 1; // make sure we update this entry
         }
 
         if (timestamp > ie->timestamp) {
            ie->event_name = xevent_name;
            ie->table_name = xtable_name;
            ie->timestamp  = timestamp;
         }
 
         //printf("%s %s %s %s %s [%s]\n", xevent_name.c_str(), xtable_name.c_str(), "???", "???", xtimestamp.c_str(), p);
         continue;
      }
 
      p = sql->GetColumn(3);
      if (p) { // tag declaration
         std::string xtag_name    = p;
         std::string xcolumn_name = sql->GetColumn(4);
         std::string xtimestamp   = sql->GetColumn(5);
         int timestamp = atoi(xtimestamp.c_str());
 
         IndexEntry* ie = FindIndexByEventName(xevent_name.c_str());
         if (!ie) {
            ie = new IndexEntry;
            gHistoryIndex.push_back(ie);
            ie->timestamp = 0;
            ie->event_name = xevent_name;
         }
 
         bool found = false;
         for (unsigned j=0; j<ie->tags.size(); j++)
            if (ie->tags[j].tag_name == xtag_name) {
               if (timestamp > ie->tags[j].timestamp) {
                  ie->tags[j].timestamp = timestamp;
                  ie->tags[j].column_name = xcolumn_name;
               }
               found = true;
               break;
            }
 
         if (!found) {
            IndexEntryTag it;
            it.tag_name = xtag_name;
            it.column_name = xcolumn_name;
            it.timestamp  = timestamp;
            ie->tags.push_back(it);
         }
 
         //printf("%s %s %s %s %s\n", xevent_name.c_str(), "???", xtag_name.c_str(), xcolumn_name.c_str(), xtimestamp.c_str());
         continue;
      }
 
   }
 
   sql->Done();
 
   gHaveIndex = true;
 
   if (event_name == NULL)
      gHaveIndexAll = true;
 
   //PrintIndex();
 
   return HS_SUCCESS;
}
 
//    Implementation of the MidasHistoryInterface     //
 
class SqlHistory: public MidasHistoryInterface
{
public:
   SqlBase *fSql;
   int fDebug;
   std::string fConnectString;
   int fConnectRetry;
   int fNextConnect;
   std::vector<Event*> fEvents;
   std::vector<std::string> fIndexEvents;
   bool fHaveIndex;
   bool fHaveXIndex;
 
   SqlHistory(SqlBase* b)
   {
      fDebug = 0;
      fConnectRetry = 0;
      fNextConnect  = 0;
      fSql = b;
      fHaveIndex = false;
      fHaveXIndex = false;
   }
 
   ~SqlHistory()
   {
      hs_disconnect();
      delete fSql;
      fSql = NULL;
   }
 
   int hs_set_debug(int debug)
   {
      int old = fDebug;
      fDebug = debug;
      gTrace = debug;
      fSql->SetDebug(debug);
      return old;
   }
 
   int hs_connect(const char* connect_string)
   {
      if (fDebug)
         printf("hs_connect %s!\n", connect_string);
 
      assert(fSql);
 
      if (fSql->IsConnected())
         if (strcmp(fConnectString.c_str(), connect_string) == 0)
            return HS_SUCCESS;
 
      hs_disconnect();
 
      fConnectString = connect_string;
 
      if (fDebug)
         printf("hs_connect: connecting to SQL database \'%s\'\n", fConnectString.c_str());
 
      int status = fSql->Connect(fConnectString.c_str());
      if (status != DB_SUCCESS)
         return status;
 
      std::vector<std::string> tables;
 
      status = fSql->ListTables(&tables);
      if (status != DB_SUCCESS)
         return status;
 
      for (unsigned i=0; i<tables.size(); i++) {
         if (tables[i] == "_history_index") {
            fHaveIndex = true;
            break;
         }
      }
 
      return HS_SUCCESS;
   }
 
   int hs_disconnect()
   {
      if (fDebug)
         printf("hs_disconnect!\n");
 
      fSql->Disconnect();
 
      hs_clear_cache();
 
      return HS_SUCCESS;
   }
 
   int Reconnect()
   {
      if (fDebug)
         printf("Reconnect to SQL database!\n");
 
      fSql->Disconnect();
      fSql->Connect(fConnectString.c_str());
      if (!fSql->IsConnected()) {
         return HS_FILE_ERROR;
      }
 
      return HS_SUCCESS;
   }
 
   //             Internal data caches                   //
 
   int hs_clear_cache()
   {
      if (fDebug)
         printf("hs_clear_cache!\n");
 
      gHaveIndex = true;
      gHaveIndexAll = false;
      fHaveXIndex = false;
 
      for (unsigned i=0; i<gHistoryIndex.size(); i++) {
         IndexEntry* ie = gHistoryIndex[i];
         delete ie;
      }
      gHistoryIndex.clear();
 
      fIndexEvents.clear();
 
      return HS_SUCCESS;
   }
 
   int XReadIndex()
   {
      if (fHaveXIndex)
         return HS_SUCCESS;
 
      if (fDebug)
         printf("XReadIndex!\n");
 
      std::vector<std::string> tables;
 
      int status = fSql->ListTables(&tables);
      if (status != DB_SUCCESS)
         return status;
 
      for (unsigned i=0; i<tables.size(); i++) {
         if (tables[i] == "_history_index")
            continue;
 
         IndexEntry* ie = NULL; //FindEventName(tables[i].c_str());
 
         if (!ie) {
            ie = new IndexEntry;
 
            ie->table_name = tables[i];
            ie->event_name = ie->table_name;
 
            gHistoryIndex.push_back(ie);
         }
 
         std::vector<std::string> columns;
 
         status = fSql->ListColumns(ie->table_name.c_str(), &columns);
         if (status != DB_SUCCESS)
            return status;
 
         for (unsigned int j=0; j<columns.size(); j+=2) {
            if (columns[j] == "_t_time")
               continue;
            if (columns[j] == "_i_time")
               continue;
 
            IndexEntryTag t;
            t.column_name = columns[j];
            t.tag_name = t.column_name;
            t.timestamp = 0;
 
            ie->tags.push_back(t);
         }
      }
 
      fHaveXIndex = true;
 
      //PrintIndex();
 
      return HS_SUCCESS;
   }
 
   //             Functions used by mlogger              //
 
   int hs_define_event(const char* event_name, time_t timestamp, int ntags, const TAG tags[])
   {
      int status;
 
      if (fDebug) {
         printf("define event [%s] with %d tags:\n", event_name, ntags);
         PrintTags(ntags, tags);
      }
 
      // delete all events with the same name
      for (unsigned int i=0; i<fEvents.size(); i++)
         if (fEvents[i])
            if (fEvents[i]->event_name == event_name) {
               if (fDebug)
                  printf("deleting exising event %s\n", event_name);
               delete fEvents[i];
               fEvents[i] = NULL;
            }
 
      Event* e = new Event();
 
      e->event_name = event_name;
 
      if (!fHaveIndex) {
         char buf[1024];
         sprintf(buf, "CREATE TABLE _history_index (event_name VARCHAR(256) NOT NULL, table_name VARCHAR(256), tag_name VARCHAR(256), column_name VARCHAR(256), itimestamp INTEGER NOT NULL);");
         int status = fSql->Exec(buf);
         if (status == DB_KEY_EXIST)
            /* do nothing */ ;
         else if (status != DB_SUCCESS)
            return status;
         fHaveIndex = true;
      }
 
      IndexEntry* ie = FindIndexByEventName(event_name);
 
      if (!ie) {
         ReadIndex(fSql, event_name);
         ie = FindIndexByEventName(event_name);
      }
 
      if (!ie) {
         std::string table_name = MidasNameToSqlName(event_name);
 
         char sss[102400];
         sprintf(sss, "INSERT INTO _history_index (event_name, table_name, itimestamp) VALUES (\'%s\', \'%s\', \'%.0f\');",
                 event_name,
                 table_name.c_str(),
                 (double)timestamp);
 
         int status = fSql->Exec(sss);
         if (status != DB_SUCCESS)
            return HS_FILE_ERROR;
 
         ReadIndex(fSql, event_name);
         ie = FindIndexByEventName(event_name);
      }
 
      if (!ie) {
         cm_msg(MERROR, "hs_define_event", "could not add event name to SQL history index table, see messages");
         return HS_FILE_ERROR;
      }
 
      e->table_name = ie->table_name;
      e->active = true;
 
      bool create_event = false;
 
      int offset = 0;
      for (int i=0; i<ntags; i++) {
         for (unsigned int j=0; j<tags[i].n_data; j++) {
            std::string tagname = tags[i].name;
            std::string colname = MidasNameToSqlName(tags[i].name);
 
            if (tags[i].n_data > 1) {
               char s[256];
               sprintf(s, "[%d]", j);
               tagname += s;
 
               sprintf(s, "_%d", j);
               colname += s;
            }
 
            IndexEntryTag *it = FindIndexByTagName(ie, tagname.c_str());
            if (!it) {
               // check for duplicate names
 
               while (1) {
                  bool dupe = false;
 
                  for (unsigned i=0; i<e->tags.size(); i++) {
                     if (colname == e->tags[i].column_name) {
                        //printf("duplicate name %s\n", colname.c_str());
                        dupe = true;
                        break;
                     }
                  }
 
                  if (!dupe)
                     break;
 
                  char s[256];
                  sprintf(s, "_%d", rand());
                  colname += s;
               }
 
               // add tag name to column name translation to the history index
 
               char sss[102400];
               sprintf(sss, "INSERT INTO _history_index (event_name, tag_name, column_name, itimestamp) VALUES (\'%s\', \'%s\', \'%s\', \'%.0f\');",
                       event_name,
                       tagname.c_str(),
                       colname.c_str(),
                       (double)timestamp);
 
               int status = fSql->Exec(sss);
               if (status != DB_SUCCESS)
                  return HS_FILE_ERROR;
 
               // reload the history index
 
               ReadIndex(fSql, event_name);
               ie = FindIndexByEventName(event_name);
               assert(ie);
               it = FindIndexByTagName(ie, tagname.c_str());
            }
 
            if (!it) {
               cm_msg(MERROR, "hs_define_event", "could not add event tags to SQL history index table, see messages");
               return HS_FILE_ERROR;
            }
 
            Tag t;
            t.column_name = it->column_name;
            t.create = false;
            t.offset = offset;
            t.tag = tags[i];
            t.tag.n_data = 1;
            e->tags.push_back(t);
            int size = tid_size[tags[i].type];
            offset += size;
         }
      }
 
      std::vector<std::string> columns;
 
      status = fSql->ListColumns(e->table_name.c_str(), &columns);
      if (status != DB_SUCCESS)
         return status;
 
      if (columns.size() <= 0)
         create_event = true;
 
      for (unsigned i=0; i<e->tags.size(); i++) {
         // check for duplicate column names
         for (unsigned j=i+1; j<e->tags.size(); j++)
            if (e->tags[i].column_name == e->tags[j].column_name) {
               cm_msg(MERROR, "hs_define_event", "Error: History event \'%s\': Duplicated column name \'%s\' from tags %d \'%s\' and %d \'%s\'", event_name, e->tags[i].column_name.c_str(), i, e->tags[i].tag.name, j, e->tags[j].tag.name);
               e->active = false;
               break;
            }
 
         // check if new column needs to be created
         bool found = false;
         for (size_t j=0; j<columns.size(); j+=2) {
            if (e->tags[i].column_name == columns[j]) {
               // column exists, check data type
               //printf("column \'%s\', data type %s\n", e->tags[i].column_name.c_str(), columns[j+1].c_str());
 
               if (!isCompatible(e->tags[i].tag.type, columns[j+1].c_str())) {
                  cm_msg(MERROR, "hs_define_event", "Error: History event \'%s\': Incompatible data type for tag \'%s\' type \'%s\', SQL column \'%s\' type \'%s\'", event_name, e->tags[i].tag.name, midasTypeName(e->tags[i].tag.type), columns[j].c_str(), columns[j+1].c_str());
                  e->active = false;
               }
 
               found = true;
               break;
            }
         }
 
         if (!found) {
            // create it
            //printf("column \'%s\', data type %s  --- create!\n", e->tags[i].column_name.c_str(), midasTypeName(e->tags[i].tag.type));
            e->tags[i].create = true;
         }
      }
 
      if (create_event) {
         char buf[1024];
         sprintf(buf, "CREATE TABLE %s (_t_time TIMESTAMP NOT NULL, _i_time INTEGER NOT NULL, INDEX (_i_time), INDEX (_t_time));", e->table_name.c_str());
         status = fSql->Exec(buf);
         if (status != DB_SUCCESS) {
            e->active = false;
            return HS_FILE_ERROR;
         }
      }
 
      for (size_t i=0; i<e->tags.size(); i++)
         if (e->tags[i].create) {
            char buf[1024];
 
            sprintf(buf, "ALTER TABLE %s ADD COLUMN %s %s;",
                    e->table_name.c_str(),
                    e->tags[i].column_name.c_str(),
                    midas2sqlType(e->tags[i].tag.type));
 
            status = fSql->Exec(buf);
 
            if (status != DB_SUCCESS) {
               e->active = false;
               return HS_FILE_ERROR;
            }
         }
 
      // find empty slot in events list
      for (unsigned int i=0; i<fEvents.size(); i++)
         if (!fEvents[i]) {
            fEvents[i] = e;
            e = NULL;
            break;
         }
 
      // if no empty slots, add at the end
      if (e)
         fEvents.push_back(e);
 
      return HS_SUCCESS;
   }
 
   int hs_write_event(const char* event_name, time_t timestamp, int buffer_size, const char* buffer)
   {
      if (fDebug)
         printf("hs_write_event: write event \'%s\', time %d, size %d\n", event_name, (int)timestamp, buffer_size);
 
      // if disconnected, try to reconnect
 
      if (!fSql->IsConnected()) {
         time_t now = time(NULL);
 
         // too early to try reconnecting?
         if (fConnectRetry !=0 && now < fNextConnect) {
            return HS_FILE_ERROR;
         }
 
         cm_msg(MINFO, "hs_write_event", "Trying to reconnect to SQL database \'%s\'", fConnectString.c_str());
 
         int status = fSql->Connect(fConnectString.c_str());
 
         if (status != DB_SUCCESS) {
 
            // first retry in 5 seconds
            if (fConnectRetry == 0)
               fConnectRetry = 5;
 
            fNextConnect = (int)(now + fConnectRetry);
 
            // exponential backoff
            fConnectRetry *= 2;
 
            // but no more than every 10 minutes
            if (fConnectRetry > 10*60)
               fConnectRetry = 10*60;
 
            return HS_FILE_ERROR;
         }
 
         cm_msg(MINFO, "hs_write_event", "Reconnected to SQL database \'%s\'", fConnectString.c_str());
      }
 
      fNextConnect = 0;
      fConnectRetry = 0;
 
      Event *e = NULL;
 
      // find this event
      for (size_t i=0; i<fEvents.size(); i++)
         if (fEvents[i]->event_name == event_name) {
            e = fEvents[i];
            break;
         }
 
      // not found
      if (!e)
         return HS_UNDEFINED_EVENT;
 
      // deactivated because of error?
      if (!e->active)
         return HS_FILE_ERROR;
 
      int status = WriteEvent(fSql, e, timestamp, buffer, buffer_size);
 
      // if could not write to SQL?
      if (status != HS_SUCCESS) {
 
         // if lost SQL connection, try again later
 
         if (!fSql->IsConnected()) {
            return HS_FILE_ERROR;
         }
 
         // otherwise, deactivate this event
 
         e->active = false;
 
         cm_msg(MERROR, "hs_write_event", "Event \'%s\' disabled after write error %d into SQL database \'%s\'", event_name, status, fConnectString.c_str());
 
         return HS_FILE_ERROR;
      }
 
      return HS_SUCCESS;
   }
 
   int hs_flush_buffers()
   {
      if (fDebug)
         printf("hs_flush_buffers!\n");
      return HS_SUCCESS;
   }
 
   //             Functions used by mhttpd               //
 
   int hs_get_events(time_t t, std::vector<std::string> *pevents)
   {
      if (fDebug)
         printf("hs_get_events!\n");
 
      if (fIndexEvents.size() == 0) {
 
         if (fDebug)
            printf("hs_get_events: reading event names!\n");
 
         ReadIndex(fSql, NULL);
 
         std::vector<std::string> tables;
         int status = fSql->ListTables(&tables);
         if (status != DB_SUCCESS)
            return status;
 
         for (unsigned i=0; i<tables.size(); i++) {
            if (tables[i] == "_history_index")
               continue;
 
            IndexEntry* ie = FindIndexByTableName(tables[i].c_str());
            if (!ie) {
               ReadIndex(fSql, NULL);
               ie = FindIndexByTableName(tables[i].c_str());
            }
 
            if (ie)
               fIndexEvents.push_back(ie->event_name);
            else
               fIndexEvents.push_back(tables[i]);
         }
      }
 
      assert(pevents);
      *pevents = fIndexEvents;
 
      return HS_SUCCESS;
   }
 
   int hs_get_tags(const char* event_name, time_t t, std::vector<TAG> *ptags)
   {
      if (fDebug)
         printf("hs_get_tags for [%s]\n", event_name);
 
      assert(ptags);
 
      IndexEntry* ie = FindIndexByEventName(event_name);
 
      if (!ie) {
         ReadIndex(fSql, event_name);
         ie = FindIndexByEventName(event_name);
      }
 
      if (!ie) {
         XReadIndex();
         ie = FindIndexByEventName(event_name);
      }
 
      if (!ie)
         return HS_UNDEFINED_EVENT;
 
      if (ie->tags_cache.size() == 0) {
         if (fDebug)
            printf("hs_get_tags reading tags for [%s]\n", event_name);
 
         std::string tname = ie->table_name;
 
         std::vector<std::string> columns;
 
         int status = fSql->ListColumns(tname.c_str(), &columns);
         if (status != DB_SUCCESS)
            return status;
 
         if (columns.size() < 1) {
            cm_msg(MERROR, "hs_get_tags", "Cannot get columns for table \'%s\', try to reconnect to the database", tname.c_str());
 
            int status = Reconnect();
            if (status != HS_SUCCESS)
               return status;
 
            columns.clear();
            status = fSql->ListColumns(tname.c_str(), &columns);
            if (status != DB_SUCCESS)
               return status;
         }
 
         //TAG* t = (TAG*)malloc(sizeof(TAG)*columns.size());
         //assert(t);
 
         for (unsigned int j=0; j<columns.size(); j+=2) {
            if (columns[j] == "_t_time")
               continue;
            if (columns[j] == "_i_time")
               continue;
 
            IndexEntryTag* it = FindIndexByColumnName(ie, columns[j].c_str());
 
            TAG t;
            if (it)
               mstrlcpy(t.name, it->tag_name.c_str(), sizeof(t.name));
            else
               mstrlcpy(t.name, columns[j].c_str(), sizeof(t.name));
            t.type = sql2midasType(columns[j+1].c_str());
            t.n_data = 1;
 
            ie->tags_cache.push_back(t);
         }
      }
 
      for (unsigned i=0; i<ie->tags_cache.size(); i++)
         ptags->push_back(ie->tags_cache[i]);
 
      return HS_SUCCESS;
   }
 
   int hs_get_last_written(time_t start_time, int num_var, const char* const event_name[], const char* const tag_name[], const int var_index[], time_t last_written[])
   {
      for (int i=0; i<num_var; i++)
         last_written[i] = 0;
      return HS_FILE_ERROR;
   }
 
   int hs_read_old_style(double start_time, double end_time, double interval,
                         const char* event_name, const char* tag_name, int var_index,
                         int *num_entries,
                         time_t** time_buffer, double**data_buffer)
   {
      if (fDebug) {
         printf("hs_read_old_style: event \"%s\", tag \"%s\"\n", event_name, tag_name);
      }
 
      ReadIndex(fSql, NULL);
 
      for (unsigned e=0; e<gHistoryIndex.size(); e++) {
 
         const char* s = gHistoryIndex[e]->event_name.c_str();
 
         bool match = false;
         for (int j=0; s[j]; j++) {
 
            if ((event_name[j]==0) && (s[j]=='/')) {
               match = true;
               break;
            }
 
            if ((event_name[j]==0) && (s[j]=='_')) {
               match = true;
               break;
            }
 
            if (event_name[j]==0) {
               match = false;
               break;
            }
 
            if (tolower(event_name[j]) != tolower(s[j])) {
               match = false;
               break;
            }
         }
 
         //printf("try %s, match %d\n", s, match);
 
         if (match) {
            bool found_tag = false;
            IndexEntry *ie = gHistoryIndex[e];
            for (unsigned v=0; v<ie->tags.size(); v++) {
               //printf("try tag [%s] looking for [%s]\n", ie->tags[v].tag_name.c_str(), tag_name);
               if (equal_ustring(tag_name, ie->tags[v].tag_name.c_str())) {
                  found_tag = true;
                  break;
               }
            }
 
            if (!found_tag)
               match = false;
         }
 
         if (match) {
            if (fDebug)
               printf("hs_read_old_style: event \"%s\", tag \"%s\", try matching event \'%s\'\n", event_name, tag_name, s);
 
            int status = hs_read(start_time, end_time, interval,
                                 s, tag_name, var_index,
                                 num_entries,
                                 time_buffer, data_buffer);
 
            if (status==HS_SUCCESS && *num_entries>0)
               return HS_SUCCESS;
         }
      }
 
      return HS_UNDEFINED_VAR;
   }
 
   int hs_read(double start_time, double end_time, double interval,
               const char* event_name, const char* tag_name, int tag_index,
               int *num_entries,
               time_t** time_buffer, double**data_buffer)
   {
      *num_entries = 0;
      *time_buffer = NULL;
      *data_buffer = NULL;
 
      if (fDebug)
         printf("hs_read: event [%s], tag [%s], index %d, start %f, end %f, dt %f, interval %f, max points %f\n",
                event_name, tag_name, tag_index,
                start_time, end_time, end_time-start_time, interval, (end_time-start_time)/interval);
 
      if (event_name==NULL)
         return HS_SUCCESS;
 
      IndexEntry*ie = FindIndexByEventName(event_name);
 
      if (!ie) {
         ReadIndex(fSql, event_name);
         ie = FindIndexByEventName(event_name);
      }
 
      if (!ie) {
         XReadIndex();
         ie = FindIndexByEventName(event_name);
      }
 
      IndexEntryTag *it = NULL;
 
      if (ie)
         it = FindIndexByTagName(ie, tag_name);
 
      if (ie && !it) { // maybe this is an array without "Names"?
         char xxx[256];
         sprintf(xxx, "%s[%d]", tag_name, tag_index);
         it = FindIndexByTagName(ie, xxx);
      }
 
      // new-style event name: "equipment_name/variable_name:tag_name"
      // old style event name: "equipment_name:tag_name" ("variable_name" is missing)
      bool oldStyleEventName = (strchr(event_name, '/')==NULL);
 
      if (oldStyleEventName)
         if (!ie || !it) {
            return hs_read_old_style(start_time, end_time, interval,
                                     event_name, tag_name, tag_index,
                                     num_entries,
                                     time_buffer, data_buffer);
         }
 
      if (!it)
         return HS_UNDEFINED_VAR;
 
      assert(ie);
      assert(it);
 
      std::string tname = ie->table_name;
      std::string cname = it->column_name;
 
      char cmd[256];
      sprintf(cmd, "SELECT _i_time, %s FROM %s WHERE _i_time>=%.0f and _i_time<=%.0f ORDER BY _i_time;",
              cname.c_str(), tname.c_str(),
              start_time, end_time);
 
      int status = fSql->Exec(cmd);
 
      if (fDebug) {
         printf("hs_read: event \"%s\", tag \"%s\", index %d: Read table \"%s\" column \"%s\": status %d, nrows: %d, ncolumns: %d\n",
                event_name, tag_name, tag_index,
                tname.c_str(),
                cname.c_str(),
                status,
                fSql->GetNumRows(),
                fSql->GetNumColumns()
                );
      }
 
      if (status != SUCCESS) {
         return HS_FILE_ERROR;
      }
 
      if (fSql->GetNumRows() == 0) {
         fSql->Done();
 
         if (oldStyleEventName) {
            return hs_read_old_style(start_time, end_time, interval,
                                     event_name, tag_name, tag_index,
                                     num_entries,
                                     time_buffer, data_buffer);
         }
 
         return HS_SUCCESS;
      }
 
      int nrows = fSql->GetNumRows();
      int ncols = fSql->GetNumColumns();
 
      if (nrows < 0)
         return HS_FILE_ERROR;
 
      if (ncols < 1)
         return HS_FILE_ERROR;
 
      *num_entries = 0;
      *time_buffer = (time_t*)malloc(nrows * sizeof(time_t));
      *data_buffer = (double*)malloc(nrows * sizeof(double));
 
      /* Loop through the rows in the result-set */
      int row = 0;
      time_t tt = 0;
      int ann = 0;
      double att = 0;
      double avv = 0;
      while (1) {
         status = fSql->Fetch();
         if (status != DB_SUCCESS)
            break;
 
         time_t t = 0;
         double v = 0;
 
         const char* timedata = fSql->GetColumn(1);
         if (timedata)
            t = atoi(timedata);
 
         const char* valuedata = fSql->GetColumn(2);
         if (valuedata)
            v = atof(valuedata);
 
         if (t < start_time || t > end_time)
            continue;
 
         //printf("Row %d, time %d, value %f\n", row, t, v);
         //printf("tt: %d, ann: %d\n", tt, ann);
 
         if (tt == 0 || t >= tt + interval) {
 
            if (ann > 0) {
               assert(row < nrows);
 
               (*time_buffer)[row] = (time_t)(att/ann);
               (*data_buffer)[row] = avv/ann;
 
               row++;
               (*num_entries) = row;
            }
 
            ann = 0;
            att = 0;
            avv = 0;
            tt  = t;
 
         }
 
         ann++;
         att += t;
         avv += v;
      }
 
      if (ann > 0) {
         assert(row < nrows);
 
         (*time_buffer)[row] = (time_t)(att/ann);
         (*data_buffer)[row] = avv/ann;
 
         row++;
         (*num_entries) = row;
      }
 
      fSql->Done();
 
      if (fDebug)
         printf("hs_read: return %d entries\n", *num_entries);
 
      return HS_SUCCESS;
   }
 
   int hs_read(time_t start_time, time_t end_time, time_t interval,
               int num_var,
               const char* const event_name[], const char* const tag_name[], const int tag_index[],
               int num_entries[],
               time_t* time_buffer[], double* data_buffer[],
               int st[])
   {
      if (fDebug)
         printf("hs_read: %d variables\n", num_var);
 
      if (!fSql->IsConnected())
         return HS_FILE_ERROR;
 
      for (int i=0; i<num_var; i++) {
 
         if (event_name[i]==NULL) {
            st[i] = HS_UNDEFINED_EVENT;
            num_entries[i] = 0;
            continue;
         }
 
         st[i] = hs_read((double)start_time, (double)end_time, (double)interval,
                         event_name[i], tag_name[i], tag_index[i],
                         &num_entries[i],
                         &time_buffer[i], &data_buffer[i]);
      }
 
      return HS_SUCCESS;
   }
 
   /*------------------------------------------------------------------*/
 
   int hs_read2(time_t start_time, time_t end_time, time_t interval,
                int num_var,
                const char* const event_name[], const char* const tag_name[], const int var_index[],
                int num_entries[],
                time_t* time_buffer[],
                double* mean_buffer[],
                double* rms_buffer[],
                double* min_buffer[],
                double* max_buffer[],
                int read_status[])
   {
      int status = hs_read(start_time, end_time, interval, num_var, event_name, tag_name, var_index, num_entries, time_buffer, mean_buffer, read_status);
 
      for (int i=0; i<num_var; i++) {
         int num = num_entries[i];
         rms_buffer[i] = (double*)malloc(sizeof(double)*num);
         min_buffer[i] = (double*)malloc(sizeof(double)*num);
         max_buffer[i] = (double*)malloc(sizeof(double)*num);
 
         for (int j=0; j<num; j++) {
            rms_buffer[i][j] = 0;
            min_buffer[i][j] = mean_buffer[i][j];
            max_buffer[i][j] = mean_buffer[i][j];
         }
      }
 
      return status;
   }
 
   /*------------------------------------------------------------------*/
 
   int hs_read_buffer(time_t start_time, time_t end_time,
                      int num_var, const char* const event_name[], const char* const tag_name[], const int var_index[],
                      MidasHistoryBufferInterface* buffer[],
                      int status[])
   {
      return HS_FILE_ERROR;
   }
 
   /*------------------------------------------------------------------*/
 
   int hs_read_binned(time_t start_time, time_t end_time, int num_bins,
                      int num_var, const char* const event_name[], const char* const tag_name[], const int var_index[],
                      int num_entries[],
                      int* count_bins[], double* mean_bins[], double* rms_bins[], double* min_bins[], double* max_bins[],
                      time_t* bins_first_time[], double* bins_first_value[],
                      time_t* bins_last_time[], double* bins_last_value[],
                      time_t last_time[], double last_value[],
                      int status[])
   {
      return HS_FILE_ERROR;
   }
};
 
//               Factory constructors                 //
 
#ifdef HAVE_ODBC
MidasHistoryInterface* MakeMidasHistoryODBC()
{
   return new SqlHistory(new SqlODBC());
}
#else
MidasHistoryInterface* MakeMidasHistoryODBC()
{
   return NULL;
}
#endif
 
MidasHistoryInterface* MakeMidasHistorySqlDebug()
{
   return new SqlHistory(new SqlDebug());
}
 
/* emacs
 * Local Variables:
 * tab-width: 8
 * c-basic-offset: 3
 * indent-tabs-mode: nil
 * End:
 */