SqlHistory Class Reference

Inheritance diagram for SqlHistory:

Collaboration diagram for SqlHistory:

Public Member Functions
	SqlHistory (SqlBase *b)
	~SqlHistory ()
int	hs_set_debug (int debug)
	set debug level, returns previous debug level
int	hs_connect (const char *connect_string)
	returns HS_SUCCESS
int	hs_disconnect ()
	disconnect from history, returns HS_SUCCESS
int	Reconnect ()
int	hs_clear_cache ()
	clear internal cache, returns HS_SUCCESS
int	XReadIndex ()
int	hs_define_event (const char *event_name, time_t timestamp, int ntags, const TAG tags[])
	see hs_define_event(), returns HS_SUCCESS or HS_FILE_ERROR
int	hs_write_event (const char *event_name, time_t timestamp, int buffer_size, const char *buffer)
	see hs_write_event(), returns HS_SUCCESS or HS_FILE_ERROR
int	hs_flush_buffers ()
	flush buffered data to storage where it is visible to mhttpd
int	hs_get_events (time_t t, std::vector< std::string > *pevents)
	get list of events that exist(ed) at given time and later (value 0 means "return all events from beginning of time"), returns HS_SUCCESS
int	hs_get_tags (const char *event_name, time_t t, std::vector< TAG > *ptags)
	get list of history variables for given event (use event names returned by hs_get_events()) that exist(ed) at given time and later (value 0 means "all variables for this event that ever existed"), also see hs_get_tags(), returns 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[])
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)
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)
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[])
	see hs_read(), returns 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	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[])
	returns HS_SUCCESS
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[])
	returns HS_SUCCESS
Public Member Functions inherited from MidasHistoryInterface
	MidasHistoryInterface ()
	history type: MIDAS, ODBC, SQLITE, etc
virtual	~MidasHistoryInterface ()

Public Attributes
SqlBase *	fSql
int	fDebug
std::string	fConnectString
int	fConnectRetry
int	fNextConnect
std::vector< Event * >	fEvents
std::vector< std::string >	fIndexEvents
bool	fHaveIndex
bool	fHaveXIndex
Public Attributes inherited from MidasHistoryInterface
char	name [NAME_LENGTH]
char	type [NAME_LENGTH]
	history channel name

Detailed Description

Definition at line 1169 of file history_odbc.cxx.

Constructor & Destructor Documentation

SqlHistory()

SqlHistory::SqlHistory ( SqlBase *  b )

inline

Definition at line 1182 of file history_odbc.cxx.

   {
      fDebug = 0;
      fConnectRetry = 0;
      fNextConnect  = 0;
      fSql = b;
      fHaveIndex = false;
      fHaveXIndex = false;
   }

~SqlHistory()

SqlHistory::~SqlHistory ( )

inline

Definition at line 1192 of file history_odbc.cxx.

   {
      hs_disconnect();
      delete fSql;
      fSql = NULL;
   }

Here is the call graph for this function:

Member Function Documentation

hs_clear_cache()

int SqlHistory::hs_clear_cache ( )

inlinevirtual

clear internal cache, returns HS_SUCCESS

Implements MidasHistoryInterface.

Definition at line 1276 of file history_odbc.cxx.

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

Here is the call graph for this function:

Here is the caller graph for this function:

hs_connect()

int SqlHistory::hs_connect ( const char *  connect_string )

inlinevirtual

returns HS_SUCCESS

Implements MidasHistoryInterface.

Definition at line 1208 of file history_odbc.cxx.

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

Here is the call graph for this function:

hs_define_event()

int SqlHistory::hs_define_event ( const char *  event_name, time_t  timestamp, int  ntags, const TAG  tags[]  )

inlinevirtual

see hs_define_event(), returns HS_SUCCESS or HS_FILE_ERROR

Implements MidasHistoryInterface.

Definition at line 1357 of file history_odbc.cxx.

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

Here is the call graph for this function:

hs_disconnect()

int SqlHistory::hs_disconnect ( )

inlinevirtual

disconnect from history, returns HS_SUCCESS

Implements MidasHistoryInterface.

Definition at line 1246 of file history_odbc.cxx.

   {
      if (fDebug)
         printf("hs_disconnect!\n");
 
      fSql->Disconnect();
 
      hs_clear_cache();
 
      return HS_SUCCESS;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

hs_flush_buffers()

int SqlHistory::hs_flush_buffers ( )

inlinevirtual

flush buffered data to storage where it is visible to mhttpd

Implements MidasHistoryInterface.

Definition at line 1668 of file history_odbc.cxx.

   {
      if (fDebug)
         printf("hs_flush_buffers!\n");
      return HS_SUCCESS;
   }

Here is the call graph for this function:

hs_get_events()

int SqlHistory::hs_get_events ( time_t  time_from, std::vector< std::string > *  pevents  )

inlinevirtual

get list of events that exist(ed) at given time and later (value 0 means "return all events from beginning of time"), returns HS_SUCCESS

Implements MidasHistoryInterface.

Definition at line 1679 of file history_odbc.cxx.

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

Here is the call graph for this function:

hs_get_last_written()

int SqlHistory::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[]  )

inlinevirtual

Implements MidasHistoryInterface.

Definition at line 1795 of file history_odbc.cxx.

   {
      for (int i=0; i<num_var; i++)
         last_written[i] = 0;
      return HS_FILE_ERROR;
   }

Here is the call graph for this function:

hs_get_tags()

int SqlHistory::hs_get_tags ( const char *  event_name, time_t  time_from, std::vector< TAG > *  ptags  )

inlinevirtual

get list of history variables for given event (use event names returned by hs_get_events()) that exist(ed) at given time and later (value 0 means "all variables for this event that ever existed"), also see hs_get_tags(), returns HS_SUCCESS

Implements MidasHistoryInterface.

Definition at line 1719 of file history_odbc.cxx.

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

Here is the call graph for this function:

hs_read() [1/2]

int SqlHistory::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  )

inline

Definition at line 1875 of file history_odbc.cxx.

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

Here is the call graph for this function:

Here is the caller graph for this function:

hs_read() [2/2]

int SqlHistory::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  var_index[], int  num_entries[], time_t *  time_buffer[], double *  data_buffer[], int  status[]  )

inlinevirtual

see hs_read(), returns HS_SUCCESS

Implements MidasHistoryInterface.

Definition at line 2054 of file history_odbc.cxx.

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

Here is the call graph for this function:

hs_read2()

int SqlHistory::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[]  )

inline

Definition at line 2086 of file history_odbc.cxx.

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

Here is the call graph for this function:

hs_read_binned()

int SqlHistory::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[]  )

inlinevirtual

returns HS_SUCCESS

Implements MidasHistoryInterface.

Definition at line 2127 of file history_odbc.cxx.

   {
      return HS_FILE_ERROR;
   }

hs_read_buffer()

int SqlHistory::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[]  )

inlinevirtual

returns HS_SUCCESS

Implements MidasHistoryInterface.

Definition at line 2117 of file history_odbc.cxx.

   {
      return HS_FILE_ERROR;
   }

hs_read_old_style()

int SqlHistory::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  )

inline

Definition at line 1802 of file history_odbc.cxx.

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

Here is the call graph for this function:

Here is the caller graph for this function:

hs_set_debug()

int SqlHistory::hs_set_debug ( int  debug )

inlinevirtual

set debug level, returns previous debug level

Implements MidasHistoryInterface.

Definition at line 1199 of file history_odbc.cxx.

   {
      int old = fDebug;
      fDebug = debug;
      gTrace = debug;
      fSql->SetDebug(debug);
      return old;
   }

Here is the call graph for this function:

hs_write_event()

int SqlHistory::hs_write_event ( const char *  event_name, time_t  timestamp, int  data_size, const char *  data  )

inlinevirtual

see hs_write_event(), returns HS_SUCCESS or HS_FILE_ERROR

Implements MidasHistoryInterface.

Definition at line 1585 of file history_odbc.cxx.

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

Here is the call graph for this function:

Reconnect()

int SqlHistory::Reconnect ( )

inline

Definition at line 1258 of file history_odbc.cxx.

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

Here is the call graph for this function:

Here is the caller graph for this function:

XReadIndex()

int SqlHistory::XReadIndex ( )

inline

Definition at line 1296 of file history_odbc.cxx.

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

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

fConnectRetry

int SqlHistory::fConnectRetry

Definition at line 1175 of file history_odbc.cxx.

fConnectString

std::string SqlHistory::fConnectString

Definition at line 1174 of file history_odbc.cxx.

fDebug

int SqlHistory::fDebug

Definition at line 1173 of file history_odbc.cxx.

fEvents

std::vector<Event*> SqlHistory::fEvents

Definition at line 1177 of file history_odbc.cxx.

fHaveIndex

bool SqlHistory::fHaveIndex

Definition at line 1179 of file history_odbc.cxx.

fHaveXIndex

bool SqlHistory::fHaveXIndex

Definition at line 1180 of file history_odbc.cxx.

fIndexEvents

std::vector<std::string> SqlHistory::fIndexEvents

Definition at line 1178 of file history_odbc.cxx.

fNextConnect

int SqlHistory::fNextConnect

Definition at line 1176 of file history_odbc.cxx.

fSql

SqlBase* SqlHistory::fSql

Definition at line 1172 of file history_odbc.cxx.

---

The documentation for this class was generated from the following file:

• src/history_odbc.cxx