history_odbc.cxx File Reference

#include "midas.h"
#include "msystem.h"
#include <vector>
#include <string>
#include "history.h"
#include "mstrlcpy.h"

Include dependency graph for history_odbc.cxx:

Go to the source code of this file.

Classes
class	SqlBase
class	SqlDebug
struct	Tag
struct	Event
struct	IndexEntryTag
struct	IndexEntry
class	SqlHistory

Macros
#define	FREE(x)   { if (x) free(x); (x) = NULL; }

Functions
static const char *	midasTypeName (int tid)
static const char *	midas2sqlType (int tid)
static int	sql2midasType (const char *name)
static bool	isCompatible (int tid, const char *sqlType)
static void	PrintTags (int ntags, const TAG tags[])
int	WriteEvent (SqlBase *sql, Event *e, time_t t, const char *buf, int size)
static std::string	MidasNameToSqlName (const char *s)
static IndexEntry *	FindIndexByTableName (const char *table_name)
static IndexEntry *	FindIndexByEventName (const char *event_name)
static IndexEntryTag *	FindIndexByTagName (IndexEntry *ie, const char *tag_name)
static IndexEntryTag *	FindIndexByColumnName (IndexEntry *ie, const char *column_name)
static int	ReadIndex (SqlBase *sql, const char *event_name)
MidasHistoryInterface *	MakeMidasHistoryODBC ()
MidasHistoryInterface *	MakeMidasHistorySqlDebug ()

Variables
static const int	tid_size []
static const char *	tid_name []
static const char *	sql_type_mysql []
static const char **	sql_type = NULL
static std::vector< IndexEntry * >	gHistoryIndex
static int	gHaveIndex = true
static int	gHaveIndexAll = false
static int	gTrace = 0

Macro Definition Documentation

FREE

#define FREE

(

x

)

{ if (x) free(x); (x) = NULL; }

Definition at line 28 of file history_odbc.cxx.

Function Documentation

FindIndexByColumnName()

static IndexEntryTag * FindIndexByColumnName ( IndexEntry *  ie, const char *  column_name  )

static

Definition at line 1006 of file history_odbc.cxx.

{
   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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

FindIndexByEventName()

static IndexEntry * FindIndexByEventName ( const char *  event_name )

static

Definition at line 988 of file history_odbc.cxx.

{
   for (unsigned i=0; i<gHistoryIndex.size(); i++)
      if (equal_ustring(gHistoryIndex[i]->event_name.c_str(), event_name)) {
         return gHistoryIndex[i];
      }
   return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

FindIndexByTableName()

static IndexEntry * FindIndexByTableName ( const char *  table_name )

static

Definition at line 979 of file history_odbc.cxx.

{
   for (unsigned i=0; i<gHistoryIndex.size(); i++)
      if (equal_ustring(gHistoryIndex[i]->table_name.c_str(), table_name)) {
         return gHistoryIndex[i];
      }
   return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

FindIndexByTagName()

static IndexEntryTag * FindIndexByTagName ( IndexEntry *  ie, const char *  tag_name  )

static

Definition at line 997 of file history_odbc.cxx.

{
   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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

isCompatible()

static bool isCompatible ( int  tid, const char *  sqlType  )

static

Definition at line 153 of file history_odbc.cxx.

{
#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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

MakeMidasHistoryODBC()

MidasHistoryInterface * MakeMidasHistoryODBC

(

)

Definition at line 2150 of file history_odbc.cxx.

{
   return NULL;
}

Here is the caller graph for this function:

MakeMidasHistorySqlDebug()

MidasHistoryInterface * MakeMidasHistorySqlDebug

(

)

Definition at line 2156 of file history_odbc.cxx.

{
   return new SqlHistory(new SqlDebug());
}

Here is the caller graph for this function:

midas2sqlType()

static const char * midas2sqlType ( int  tid )

static

Definition at line 137 of file history_odbc.cxx.

{
   assert(tid>=0);
   assert(tid<15);
   return sql_type[tid];
}

Here is the caller graph for this function:

MidasNameToSqlName()

static std::string MidasNameToSqlName ( const char *  s )

static

Definition at line 932 of file history_odbc.cxx.

{
   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;
}

Here is the caller graph for this function:

midasTypeName()

static const char * midasTypeName ( int  tid )

static

Definition at line 130 of file history_odbc.cxx.

{
   assert(tid>=0);
   assert(tid<15);
   return tid_name[tid];
}

Here is the caller graph for this function:

PrintTags()

static void PrintTags ( int  ntags, const TAG  tags[]  )

static

Definition at line 824 of file history_odbc.cxx.

{
   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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ReadIndex()

static int ReadIndex ( SqlBase *  sql, const char *  event_name  )

static

Definition at line 1020 of file history_odbc.cxx.

{
   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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sql2midasType()

static int sql2midasType ( const char *  name )

static

Definition at line 144 of file history_odbc.cxx.

{
   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;
}

Here is the caller graph for this function:

WriteEvent()

int WriteEvent	(	SqlBase *	sql,
		Event *	e,
		time_t	t,
		const char *	buf,
		int	size
	)

Definition at line 830 of file history_odbc.cxx.

{
   //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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

gHaveIndex

int gHaveIndex = true

static

Definition at line 1015 of file history_odbc.cxx.

gHaveIndexAll

int gHaveIndexAll = false

static

Definition at line 1016 of file history_odbc.cxx.

gHistoryIndex

std::vector<IndexEntry*> gHistoryIndex

static

Definition at line 963 of file history_odbc.cxx.

gTrace

int gTrace = 0

static

Definition at line 1018 of file history_odbc.cxx.

sql_type

const char** sql_type = NULL

static

Definition at line 128 of file history_odbc.cxx.

sql_type_mysql

const char* sql_type_mysql[]

static

Initial value:

= {
   "xxxINVALIDxxxNULL", 
   "tinyint unsigned",  
   "tinyint",           
   "char",              
   "smallint unsigned", 
   "smallint",          
   "integer unsigned",  
   "integer",           
   "tinyint",           
   "float",             
   "double",            
   "integer unsigned",  
   "VARCHAR",           
   "xxxINVALIDxxxARRAY",
   "xxxINVALIDxxxSTRUCT",
   "xxxINVALIDxxxKEY",
   "xxxINVALIDxxxLINK"
}

Definition at line 104 of file history_odbc.cxx.

                                      {
   "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"
};

tid_name

const char* tid_name[]

static

Initial value:

= {
   "NULL",
   "UINT8",
   "INT8",
   "CHAR",
   "UINT16",
   "INT16",
   "UINT32",
   "INT32",
   "BOOL",
   "FLOAT",
   "DOUBLE",
   "BITFIELD",
   "STRING",
   "ARRAY",
   "STRUCT",
   "KEY",
   "LINK",
   "INT64",
   "UINT64"
}

Definition at line 59 of file history_odbc.cxx.

                                {
   "NULL",
   "UINT8",
   "INT8",
   "CHAR",
   "UINT16",
   "INT16",
   "UINT32",
   "INT32",
   "BOOL",
   "FLOAT",
   "DOUBLE",
   "BITFIELD",
   "STRING",
   "ARRAY",
   "STRUCT",
   "KEY",
   "LINK",
   "INT64",
   "UINT64"
};

tid_size

const int tid_size[]

static

Initial value:

= {
   0,                           
   1,                           
   1,                           
   1,                           
   2,                           
   2,                           
   4,                           
   4,                           
   4,                           
   4,                           
   8,                           
   4,                           
   0,                           
   0,                           
   0,                           
   0,                           
   0,                           
   8,                           
   8                            
}

Definition at line 36 of file history_odbc.cxx.

                              {
   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  */
};