Inheritance diagram for SqlHistoryBase:

[legend]

Collaboration diagram for SqlHistoryBase:

[legend]

Public Member Functions
	SqlHistoryBase ()

virtual	~SqlHistoryBase ()

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

HsSchema *	new_event (const char *event_name, time_t timestamp, int ntags, const TAG tags[])

int	read_schema (HsSchemaVector sv, const char event_name, const time_t timestamp)

Public Member Functions inherited from SchemaHistoryBase
	SchemaHistoryBase ()

virtual	~SchemaHistoryBase ()

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_clear_cache ()
	clear internal cache, returns HS_SUCCESS

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 timestamp, int num_var, const char const event_name[], const char const var_name[], const int var_index[], time_t last_written[])

int	hs_read_buffer (time_t start_time, time_t end_time, int num_var, const char const event_name[], const char const var_name[], const int var_index[], MidasHistoryBufferInterface *buffer[], int hs_status[])
	returns 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 var_name[], const int var_index[], int num_entries[], time_t time_buffer[], double data_buffer[], int st[])
	see hs_read(), 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 var_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 st[])
	returns HS_SUCCESS

Public Member Functions inherited from MidasHistoryInterface
	MidasHistoryInterface ()
	history type: MIDAS, ODBC, SQLITE, etc

virtual	~MidasHistoryInterface ()

Public Attributes
SqlBase *	fSql

Public Attributes inherited from MidasHistoryInterface
char	name [NAME_LENGTH]

char	type [NAME_LENGTH]
	history channel name

Protected Member Functions
virtual int	read_table_and_event_names (HsSchemaVector *sv)=0

virtual int	read_column_names (HsSchemaVector sv, const char table_name, const char *event_name)=0

virtual int	create_table (HsSchemaVector sv, const char event_name, time_t timestamp)=0

virtual int	update_column (const char event_name, const char table_name, const char column_name, const char column_type, const char tag_name, const char tag_type, const time_t timestamp, bool active, bool *have_transaction)=0

int	update_schema (HsSqlSchema *s, const time_t timestamp, const int ntags, const TAG tags[], bool write_enable)

int	update_schema1 (HsSqlSchema s, const time_t timestamp, const int ntags, const TAG tags[], bool write_enable, bool have_transaction)

Additional Inherited Members
Protected Attributes inherited from SchemaHistoryBase
int	fDebug

std::string	fConnectString

HsSchemaVector	fWriterCurrentSchema

std::vector< HsSchema * >	fEvents

HsSchemaVector	fSchema

Detailed Description

Definition at line 4617 of file history_schema.cxx.

Constructor & Destructor Documentation

◆ SqlHistoryBase()

SqlHistoryBase::SqlHistoryBase ( )

inline

Definition at line 4622 of file history_schema.cxx.

   {
      fSql = NULL;
      hs_clear_cache();
   }

Here is the call graph for this function:

◆ ~SqlHistoryBase()

virtual SqlHistoryBase::~SqlHistoryBase ( )

inlinevirtual

Definition at line 4628 of file history_schema.cxx.

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

Here is the call graph for this function:

Member Function Documentation

◆ create_table()

virtual int SqlHistoryBase::create_table	(	HsSchemaVector *	sv,
		const char *	event_name,
		time_t	timestamp
	)

protectedpure virtual

Implemented in SqliteHistory, and MysqlHistory.

Here is the caller graph for this function:

◆ hs_connect()

int SqlHistoryBase::hs_connect ( const char * connect_string )

virtual

returns HS_SUCCESS

Implements SchemaHistoryBase.

Definition at line 4658 of file history_schema.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();
 
   if (!connect_string || strlen(connect_string) < 1) {
      // FIXME: should use "logger dir" or some such default, that code should be in hs_get_history(), not here
      connect_string = ".";
   }
 
   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;
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

◆ hs_disconnect()

int SqlHistoryBase::hs_disconnect ( )

virtual

disconnect from history, returns HS_SUCCESS

Implements SchemaHistoryBase.

Definition at line 4688 of file history_schema.cxx.

{
   if (fDebug)
      printf("hs_disconnect!\n");
 
   hs_flush_buffers();
 
   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_set_debug()

int SqlHistoryBase::hs_set_debug ( int debug )

inlinevirtual

set debug level, returns previous debug level

Reimplemented from SchemaHistoryBase.

Definition at line 4636 of file history_schema.cxx.

   {
      if (fSql)
         fSql->fDebug = debug;
      return SchemaHistoryBase::hs_set_debug(debug);
   }

Here is the call graph for this function:

◆ new_event()

HsSchema * SqlHistoryBase::new_event	(	const char *	event_name,
		time_t	timestamp,
		int	ntags,
		const TAG	tags[]
	)

virtual

Implements SchemaHistoryBase.

Definition at line 4702 of file history_schema.cxx.

{
   if (fDebug)
      printf("SqlHistory::new_event: event [%s], timestamp %s, ntags %d\n", event_name, TimeToString(timestamp).c_str(), ntags);
 
   int status;
 
   if (fWriterCurrentSchema.size() == 0) {
      status = read_table_and_event_names(&fWriterCurrentSchema);
      if (status != HS_SUCCESS)
         return NULL;
   }
 
   HsSqlSchema* s = (HsSqlSchema*)fWriterCurrentSchema.find_event(event_name, timestamp);
 
   // schema does not exist, the SQL tables probably do not exist yet
 
   if (!s) {
      status = create_table(&fWriterCurrentSchema, event_name, timestamp);
      if (status != HS_SUCCESS)
         return NULL;
 
      s = (HsSqlSchema*)fWriterCurrentSchema.find_event(event_name, timestamp);
 
      if (!s) {
         cm_msg(MERROR, "SqlHistory::new_event", "Error: Cannot create schema for event \'%s\', see previous messages", event_name);
         fWriterCurrentSchema.find_event(event_name, timestamp, 1);
         return NULL;
      }
   }
 
   assert(s != NULL);
 
   status = read_column_names(&fWriterCurrentSchema, s->table_name.c_str(), s->event_name.c_str());
   if (status != HS_SUCCESS)
      return NULL;
 
   s = (HsSqlSchema*)fWriterCurrentSchema.find_event(event_name, timestamp);
 
   if (!s) {
      cm_msg(MERROR, "SqlHistory::new_event", "Error: Cannot update schema database for event \'%s\', see previous messages", event_name);
      return NULL;
   }
 
   if (0||fDebug) {
      printf("SqlHistory::new_event: schema for [%s] is %p\n", event_name, s);
      if (s)
         s->print();
   }
 
   status = update_schema(s, timestamp, ntags, tags, true);
   if (status != HS_SUCCESS) {
      cm_msg(MERROR, "SqlHistory::new_event", "Error: Cannot create schema for event \'%s\', see previous messages", event_name);
      return NULL;
   }
 
   status = read_column_names(&fWriterCurrentSchema, s->table_name.c_str(), s->event_name.c_str());
   if (status != HS_SUCCESS)
      return NULL;
 
   s = (HsSqlSchema*)fWriterCurrentSchema.find_event(event_name, timestamp);
 
   if (!s) {
      cm_msg(MERROR, "SqlHistory::new_event", "Error: Cannot update schema database for event \'%s\', see previous messages", event_name);
      return NULL;
   }
 
   if (0||fDebug) {
      printf("SqlHistory::new_event: schema for [%s] is %p\n", event_name, s);
      if (s)
         s->print();
   }
 
   // last call to UpdateMysqlSchema with "false" will check that new schema matches the new tags
 
   status = update_schema(s, timestamp, ntags, tags, false);
   if (status != HS_SUCCESS) {
      cm_msg(MERROR, "SqlHistory::new_event", "Error: Cannot create schema for event \'%s\', see previous messages", event_name);
      //fDebug = 1;
      //update_schema(s, timestamp, ntags, tags, false);
      //abort();
      return NULL;
   }
 
   HsSqlSchema* e = new HsSqlSchema();
 
   *e = *s; // make a copy of the schema
 
   return e;
}

Here is the call graph for this function:

◆ read_column_names()

virtual int SqlHistoryBase::read_column_names	(	HsSchemaVector *	sv,
		const char *	table_name,
		const char *	event_name
	)

protectedpure virtual

Implemented in SqliteHistory, and MysqlHistory.

Here is the caller graph for this function:

◆ read_schema()

int SqlHistoryBase::read_schema	(	HsSchemaVector *	sv,
		const char *	event_name,
		const time_t	timestamp
	)

virtual

Implements SchemaHistoryBase.

Definition at line 4793 of file history_schema.cxx.

{
   if (fDebug)
      printf("SqlHistory::read_schema: loading schema for event [%s] at time %s\n", event_name, TimeToString(timestamp).c_str());
 
   int status;
 
   if (fSchema.size() == 0) {
      status = read_table_and_event_names(sv);
      if (status != HS_SUCCESS)
         return status;
   }
 
   //sv->print(false);
 
   if (event_name == NULL)
      return HS_SUCCESS;
 
   for (unsigned i=0; i<sv->size(); i++) {
      HsSqlSchema* h = (HsSqlSchema*)(*sv)[i];
      // skip schema with already read column names
      if (h->variables.size() > 0)
         continue;
      // skip schema with different name
      if (!MatchEventName(h->event_name.c_str(), event_name))
         continue;
 
      unsigned nn = sv->size();
 
      status = read_column_names(sv, h->table_name.c_str(), h->event_name.c_str());
 
      // if new schema was added, loop all over again
      if (sv->size() != nn)
         i=0;
   }
 
   //sv->print(false);
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

◆ read_table_and_event_names()

virtual int SqlHistoryBase::read_table_and_event_names ( HsSchemaVector * sv )

protectedpure virtual

Implemented in SqliteHistory, and MysqlHistory.

Here is the caller graph for this function:

◆ update_column()

virtual int SqlHistoryBase::update_column	(	const char *	event_name,
		const char *	table_name,
		const char *	column_name,
		const char *	column_type,
		const char *	tag_name,
		const char *	tag_type,
		const time_t	timestamp,
		bool	active,
		bool *	have_transaction
	)

protectedpure virtual

Implemented in SqliteHistory, and MysqlHistory.

Here is the caller graph for this function:

◆ update_schema()

int SqlHistoryBase::update_schema	(	HsSqlSchema *	s,
		const time_t	timestamp,
		const int	ntags,
		const TAG	tags[],
		bool	write_enable
	)

protected

Definition at line 4834 of file history_schema.cxx.

{
   int status;
   bool have_transaction = false;
 
   status = update_schema1(s, timestamp, ntags, tags, write_enable, &have_transaction);
 
   if (have_transaction) {
      int xstatus;
 
      if (status == HS_SUCCESS)
         xstatus = fSql->CommitTransaction(s->table_name.c_str());
      else
         xstatus = fSql->RollbackTransaction(s->table_name.c_str());
 
      if (xstatus != DB_SUCCESS) {
         return HS_FILE_ERROR;
      }
      have_transaction = false;
   }
 
   return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_schema1()

int SqlHistoryBase::update_schema1	(	HsSqlSchema *	s,
		const time_t	timestamp,
		const int	ntags,
		const TAG	tags[],
		bool	write_enable,
		bool *	have_transaction
	)

protected

Definition at line 4858 of file history_schema.cxx.

{
   int status;
 
   if (fDebug)
      printf("update_schema1\n");
 
   // check that compare schema with tags[]
 
   bool schema_ok = true;
 
   int offset = 0;
   for (int i=0; i<ntags; i++) {
      for (unsigned int j=0; j<tags[i].n_data; j++) {
         int         tagtype = tags[i].type;
         std::string tagname = tags[i].name;
         std::string maybe_colname = MidasNameToSqlName(tags[i].name);
 
         if (tags[i].n_data > 1) {
            char s[256];
            sprintf(s, "[%d]", j);
            tagname += s;
 
            sprintf(s, "_%d", j);
            maybe_colname += s;
         }
 
         int count = 0;
 
         for (unsigned j=0; j<s->variables.size(); j++) {
            // NB: inactive columns will be reactivated or recreated by the if(count==0) branch. K.O.
            if (s->variables[j].inactive)
               continue;
            if (tagname == s->variables[j].name) {
               if (s->sql->TypesCompatible(tagtype, s->column_types[j].c_str())) {
                  if (count == 0) {
                     s->offsets[j] = offset;
                     offset += rpc_tid_size(tagtype);
                  }
                  count++;
                  if (count > 1) {
                     cm_msg(MERROR, "SqlHistory::update_schema", "Duplicate SQL column \'%s\' type \'%s\' in table \"%s\" with MIDAS type \'%s\' history event \"%s\" tag \"%s\"", s->column_names[j].c_str(), s->column_types[j].c_str(), s->table_name.c_str(), rpc_tid_name(tagtype), s->event_name.c_str(), tagname.c_str());
                     cm_msg_flush_buffer();
                  }
               } else {
                  // column with incompatible type, mark it as unused
                  schema_ok = false;
                  if (fDebug)
                     printf("Incompatible column!\n");
                  if (write_enable) {
                     cm_msg(MINFO, "SqlHistory::update_schema", "Deactivating SQL column \'%s\' type \'%s\' in table \"%s\" as incompatible with MIDAS type \'%s\' history event \"%s\" tag \"%s\"", s->column_names[j].c_str(), s->column_types[j].c_str(), s->table_name.c_str(), rpc_tid_name(tagtype), s->event_name.c_str(), tagname.c_str());
                     cm_msg_flush_buffer();
 
                     status = update_column(s->event_name.c_str(), s->table_name.c_str(), s->column_names[j].c_str(), s->column_types[j].c_str(), s->variables[j].tag_name.c_str(), s->variables[i].tag_type.c_str(), timestamp, false, have_transaction);
                     if (status != HS_SUCCESS)
                        return status;
                  }
               }
            }
         }
 
         if (count == 0) {
            // tag does not have a corresponding column
            schema_ok = false;
            if (fDebug)
               printf("No column for tag %s!\n", tagname.c_str());
 
            bool found_column = false;
            
            if (write_enable) {
               for (unsigned j=0; j<s->variables.size(); j++) {
                  if (tagname == s->variables[j].tag_name) {
                     bool typeok = s->sql->TypesCompatible(tagtype, s->column_types[j].c_str());
                     if (typeok) {
                        cm_msg(MINFO, "SqlHistory::update_schema", "Reactivating SQL column \'%s\' type \'%s\' in table \"%s\" for history event \"%s\" tag \"%s\"", s->column_names[j].c_str(), s->column_types[j].c_str(), s->table_name.c_str(), s->event_name.c_str(), tagname.c_str());
                        cm_msg_flush_buffer();
 
                        status = update_column(s->event_name.c_str(), s->table_name.c_str(), s->column_names[j].c_str(), s->column_types[j].c_str(), s->variables[j].tag_name.c_str(), s->variables[j].tag_type.c_str(), timestamp, true, have_transaction);
                        if (status != HS_SUCCESS)
                           return status;
 
                        if (count == 0) {
                           s->offsets[j] = offset;
                           offset += rpc_tid_size(tagtype);
                        }
                        count++;
                        found_column = true;
                        if (count > 1) {
                           cm_msg(MERROR, "SqlHistory::update_schema", "Duplicate SQL column \'%s\' type \'%s\' in table \"%s\" for history event \"%s\" tag \"%s\"", s->column_names[j].c_str(), s->column_types[j].c_str(), s->table_name.c_str(), s->event_name.c_str(), tagname.c_str());
                           cm_msg_flush_buffer();
                        }
                     }
                  }
               }
            }
 
            // create column
            if (!found_column && write_enable) {
               std::string col_name = maybe_colname;
               const char* col_type = s->sql->ColumnType(tagtype);
 
               bool dupe = false;
               for (unsigned kk=0; kk<s->column_names.size(); kk++)
                  if (s->column_names[kk] == col_name) {
                     dupe = true;
                     break;
                  }
 
               time_t now = time(NULL);
               
               bool retry = false;
               for (int t=0; t<20; t++) {
 
                  // if duplicate column name, change it, try again
                  if (dupe || retry) {
                     col_name = maybe_colname;
                     col_name += "_";
                     col_name += TimeToString(now);
                     if (t > 0) {
                        char s[256];
                        sprintf(s, "_%d", t);
                        col_name += s;
                     }
                  }
 
                  if (fDebug)
                     printf("SqlHistory::update_schema: table [%s], add column [%s] type [%s] for tag [%s]\n", s->table_name.c_str(), col_name.c_str(), col_type, tagname.c_str());
 
                  status = CreateSqlColumn(fSql, s->table_name.c_str(), col_name.c_str(), col_type, have_transaction, fDebug);
 
                  if (status == DB_KEY_EXIST) {
                     if (fDebug)
                        printf("SqlHistory::update_schema: table [%s], add column [%s] type [%s] for tag [%s] failed: duplicate column name\n", s->table_name.c_str(), col_name.c_str(), col_type, tagname.c_str());
                     retry = true;
                     continue;
                  }
 
                  if (status != HS_SUCCESS)
                     return status;
 
                  break;
               }
 
               if (status != HS_SUCCESS)
                  return status;
 
               status = update_column(s->event_name.c_str(), s->table_name.c_str(), col_name.c_str(), col_type, tagname.c_str(), rpc_tid_name(tagtype), timestamp, true, have_transaction);
               if (status != HS_SUCCESS)
                  return status;
            }
         }
 
         if (count > 1) {
            // schema has duplicate tags
            schema_ok = false;
            cm_msg(MERROR, "SqlHistory::update_schema", "Duplicate tags or SQL columns for history event \"%s\" tag \"%s\"", s->event_name.c_str(), tagname.c_str());
            cm_msg_flush_buffer();
         }
      }
   }
 
   // mark as unused all columns not listed in tags
 
   for (unsigned k=0; k<s->column_names.size(); k++)
      if (s->variables[k].name.length() > 0) {
         bool found = false;
 
         for (int i=0; i<ntags; i++) {
            for (unsigned int j=0; j<tags[i].n_data; j++) {
               std::string tagname = tags[i].name;
 
               if (tags[i].n_data > 1) {
                  char s[256];
                  sprintf(s, "[%d]", j);
                  tagname += s;
               }
 
               if (s->variables[k].name == tagname) {
                  found = true;
                  break;
               }
            }
 
            if (found)
               break;
         }
 
         if (!found) {
            // column not found in tags list
            schema_ok = false;
            if (fDebug)
               printf("Event [%s] Column [%s] tag [%s] not listed in tags list!\n", s->event_name.c_str(), s->column_names[k].c_str(), s->variables[k].name.c_str());
            if (write_enable) {
               cm_msg(MINFO, "SqlHistory::update_schema", "Deactivating SQL column \'%s\' type \'%s\' in table \"%s\" for history event \"%s\" not used for any tags", s->column_names[k].c_str(), s->column_types[k].c_str(), s->table_name.c_str(), s->event_name.c_str());
               cm_msg_flush_buffer();
 
               status = update_column(s->event_name.c_str(), s->table_name.c_str(), s->column_names[k].c_str(), s->column_types[k].c_str(), s->variables[k].tag_name.c_str(), s->variables[k].tag_type.c_str(), timestamp, false, have_transaction);
               if (status != HS_SUCCESS)
                  return status;
            }
         }
      }
 
   if (!write_enable)
      if (!schema_ok) {
         if (fDebug)
            printf("Return error!\n");
         return HS_FILE_ERROR;
      }
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ fSql

SqlBase* SqlHistoryBase::fSql

Definition at line 4620 of file history_schema.cxx.

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

src/history_schema.cxx

Public Member Functions

Public Attributes

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ SqlHistoryBase()

◆ ~SqlHistoryBase()

Member Function Documentation

◆ create_table()

◆ hs_connect()

◆ hs_disconnect()

◆ hs_set_debug()

◆ new_event()

◆ read_column_names()

◆ read_schema()

◆ read_table_and_event_names()

◆ update_column()

◆ update_schema()

◆ update_schema1()

Member Data Documentation

◆ fSql