MysqlHistory Class Reference

Inheritance diagram for MysqlHistory:

Collaboration diagram for MysqlHistory:

Public Member Functions
	MysqlHistory ()
int	read_table_and_event_names (HsSchemaVector *sv)
int	read_column_names (HsSchemaVector *sv, const char *table_name, const char *event_name)
int	create_table (HsSchemaVector *sv, const char *event_name, time_t timestamp)
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)
Public Member Functions inherited from SqlHistoryBase
	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)
HsSchema *	maybe_reopen (const char *event_name, time_t timestamp, HsSchema *s)
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 ()

Additional Inherited Members
Public Attributes inherited from SqlHistoryBase
SqlBase *	fSql
Public Attributes inherited from MidasHistoryInterface
char	name [NAME_LENGTH]
char	type [NAME_LENGTH]
	history channel name
Protected Member Functions inherited from SqlHistoryBase
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)
Protected Attributes inherited from SchemaHistoryBase
int	fDebug = 0
std::string	fConnectString
HsSchemaVector	fWriterSchema
std::vector< HsSchema * >	fWriterEvents
HsSchemaVector	fReaderSchema

Detailed Description

Definition at line 5571 of file history_schema.cxx.

Constructor & Destructor Documentation

MysqlHistory()

MysqlHistory::MysqlHistory ( )

inline

Definition at line 5574 of file history_schema.cxx.

                  { // ctor
#ifdef HAVE_MYSQL
      fSql = new Mysql();
#endif
   }

Here is the call graph for this function:

Member Function Documentation

create_table()

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

virtual

Implements SqlHistoryBase.

Definition at line 5873 of file history_schema.cxx.

{
   if (fDebug)
      printf("MysqlHistory::create_table: event [%s], timestamp %s\n", event_name, TimeToString(timestamp).c_str());
 
   int status;
   std::string table_name = MidasNameToSqlName(event_name);
 
   // MySQL table name length limit is 64 bytes
   if (table_name.length() > 40) {
      table_name.resize(40);
      table_name += "_T";
   }
 
   time_t now = time(NULL);
 
   int max_attempts = 10;
   for (int i=0; i<max_attempts; i++) {
      status = fSql->OpenTransaction(table_name.c_str());
      if (status != DB_SUCCESS) {
         return HS_FILE_ERROR;
      }
 
      bool have_transaction = true;
 
      std::string xtable_name = table_name;
 
      if (i>0) {
         xtable_name += "_";
         xtable_name += TimeToString(now);
         if (i>1) {
            xtable_name += "_";
            char buf[256];
            sprintf(buf, "%d", i);
            xtable_name += buf;
         }
      }
      
      status = CreateSqlTable(fSql, xtable_name.c_str(), &have_transaction);
 
      //printf("event [%s] create table [%s] status %d\n", event_name, xtable_name.c_str(), status);
 
      if (status == DB_KEY_EXIST) {
         // already exists, try with different name!
         fSql->RollbackTransaction(table_name.c_str());
         continue;
      }
 
      if (status != HS_SUCCESS) {
         // MYSQL cannot roll back "create table", if we cannot create SQL tables, nothing will work. Give up now.
         cm_msg(MERROR, "MysqlHistory::create_table", "Could not create table [%s] for event [%s], timestamp %s, please fix the SQL database configuration and try again", table_name.c_str(), event_name, TimeToString(timestamp).c_str());
         abort();
 
         // fatal error, give up!
         fSql->RollbackTransaction(table_name.c_str());
         break;
      }
 
      for (int j=0; j<2; j++) {
         std::string cmd;
         cmd += "INSERT INTO _history_index (event_name, table_name, itimestamp, active) VALUES (";
         cmd += fSql->QuoteString(event_name);
         cmd += ", ";
         cmd += fSql->QuoteString(xtable_name.c_str());
         cmd += ", ";
         char buf[256];
         sprintf(buf, "%.0f", (double)timestamp);
         cmd += fSql->QuoteString(buf);
         cmd += ", ";
         cmd += fSql->QuoteString("1");
         cmd += ");";
         
         int status = fSql->Exec(table_name.c_str(), cmd.c_str());
         if (status == DB_SUCCESS)
            break;
         
         status = CreateSqlTable(fSql,  "_history_index", &have_transaction);
         status = CreateSqlColumn(fSql, "_history_index", "event_name",  "varchar(256) character set binary not null", &have_transaction, fDebug);
         status = CreateSqlColumn(fSql, "_history_index", "table_name",  "varchar(256)",     &have_transaction, fDebug);
         status = CreateSqlColumn(fSql, "_history_index", "tag_name",    "varchar(256) character set binary",     &have_transaction, fDebug);
         status = CreateSqlColumn(fSql, "_history_index", "tag_type",    "varchar(256)",     &have_transaction, fDebug);
         status = CreateSqlColumn(fSql, "_history_index", "column_name", "varchar(256)",     &have_transaction, fDebug);
         status = CreateSqlColumn(fSql, "_history_index", "column_type", "varchar(256)",     &have_transaction, fDebug);
         status = CreateSqlColumn(fSql, "_history_index", "itimestamp",  "integer not null", &have_transaction, fDebug);
         status = CreateSqlColumn(fSql, "_history_index", "active",      "boolean",          &have_transaction, fDebug);
      }
 
      status = fSql->CommitTransaction(table_name.c_str());
 
      if (status != DB_SUCCESS) {
         return HS_FILE_ERROR;
      }
      
      return ReadMysqlTableNames(fSql, sv, xtable_name.c_str(), fDebug, event_name, xtable_name.c_str());
   }
 
   cm_msg(MERROR, "MysqlHistory::create_table", "Could not create table [%s] for event [%s], timestamp %s, after %d attempts", table_name.c_str(), event_name, TimeToString(timestamp).c_str(), max_attempts);
 
   return HS_FILE_ERROR;
}

Here is the call graph for this function:

read_column_names()

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

virtual

Implements SqlHistoryBase.

Definition at line 5668 of file history_schema.cxx.

{
   if (fDebug)
      printf("MysqlHistory::read_column_names: table [%s], event [%s]\n", table_name, event_name);
 
   // for all schema for table_name, prepopulate is with column names
 
   std::vector<std::string> columns;
   fSql->ListColumns(table_name, &columns);
 
   // first, populate column names
 
   for (size_t i=0; i<sv->size(); i++) {
      HsSqlSchema* s = (HsSqlSchema*)(*sv)[i];
 
      if (s->fTableName != table_name)
         continue;
 
      // schema should be empty at this point
      //assert(s->fVariables.size() == 0);
 
      for (size_t j=0; j<columns.size(); j+=2) {
         const char* cn = columns[j+0].c_str();
         const char* ct = columns[j+1].c_str();
 
         if (strcmp(cn, "_t_time") == 0)
            continue;
         if (strcmp(cn, "_i_time") == 0)
            continue;
 
         bool found = false;
 
         for (size_t k=0; k<s->fColumnNames.size(); k++) {
            if (s->fColumnNames[k] == cn) {
               found = true;
               break;
            }
         }
 
         //printf("column [%s] sql type [%s]\n", cn.c_str(), ct);
 
         if (!found) {
            HsSchemaEntry se;
            se.tag_name = cn;
            se.tag_type = "";
            se.name = cn;
            se.type = 0;
            se.n_data = 1;
            se.n_bytes = 0;
            s->fVariables.push_back(se);
            s->fColumnNames.push_back(cn);
            s->fColumnTypes.push_back(ct);
            s->fColumnInactive.push_back(false);
            s->fOffsets.push_back(-1);
         }
      }
   }
 
   // then read column name information
 
   std::string cmd;
   cmd = "SELECT column_name, column_type, tag_name, tag_type, itimestamp, active FROM _history_index WHERE event_name=";
   cmd += fSql->QuoteString(event_name);
   cmd += ";";
 
   int status = fSql->Prepare(table_name, cmd.c_str());
 
   if (status != DB_SUCCESS) {
      return status;
   }
 
   while (1) {
      status = fSql->Step();
 
      if (status != DB_SUCCESS)
         break;
 
      const char* col_name  = fSql->GetText(0);
      const char* col_type  = fSql->GetText(1);
      const char* tag_name  = fSql->GetText(2);
      const char* tag_type  = fSql->GetText(3);
      time_t   schema_time  = fSql->GetTime(4);
      const char* active    = fSql->GetText(5);
      int iactive = atoi(active);
 
      //printf("read table [%s] column [%s] type [%s] tag name [%s] type [%s] time %s active [%s] %d\n", table_name, col_name, col_type, tag_name, tag_type, TimeToString(schema_time).c_str(), active, iactive);
 
      if (!col_name)
         continue;
      if (!tag_name)
         continue;
      if (strlen(col_name) < 1)
         continue;
 
      // make sure a schema exists at this time point
      NewSqlSchema(sv, table_name, schema_time);
 
      // add this information to all schema
 
      for (size_t i=0; i<sv->size(); i++) {
         HsSqlSchema* s = (HsSqlSchema*)(*sv)[i];
         if (s->fTableName != table_name)
            continue;
         if (s->fTimeFrom < schema_time)
            continue;
 
         int tid = rpc_name_tid(tag_type);
         int tid_size = rpc_tid_size(tid);
 
         for (size_t j=0; j<s->fColumnNames.size(); j++) {
            if (col_name != s->fColumnNames[j])
               continue;
 
            s->fVariables[j].tag_name = tag_name;
            s->fVariables[j].tag_type = tag_type;
            if (!iactive) {
               s->fVariables[j].name = "";
               s->fColumnInactive[j] = true;
            } else {
               s->fVariables[j].name = tag_name;
               s->fColumnInactive[j] = false;
            }
            s->fVariables[j].type = tid;
            s->fVariables[j].n_data = 1;
            s->fVariables[j].n_bytes = tid_size;
 
            // doctor column names in case MySQL returns different type
            // from the type used to create the column, but the types
            // are actually the same. K.O.
            DoctorSqlColumnType(&s->fColumnTypes[j], col_type);
         }
      }
   }
 
   status = fSql->Finalize();
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

read_table_and_event_names()

int MysqlHistory::read_table_and_event_names ( HsSchemaVector *  sv )

virtual

Implements SqlHistoryBase.

Definition at line 5828 of file history_schema.cxx.

{
   int status;
 
   if (fDebug)
      printf("MysqlHistory::read_table_and_event_names!\n");
 
   // loop over all tables
 
   std::vector<std::string> tables;
   status = fSql->ListTables(&tables);
   if (status != DB_SUCCESS)
      return status;
 
   for (size_t i=0; i<tables.size(); i++) {
      const char* table_name = tables[i].c_str();
 
      const char* s;
      s = strstr(table_name, "_history_index");
      if (s == table_name)
         continue;
 
      if (1) {
         // seed schema with table names
         HsSqlSchema* s = new HsSqlSchema;
         s->fSql = fSql;
         s->fEventName = table_name;
         s->fTimeFrom = 0;
         s->fTimeTo = 0;
         s->fTableName = table_name;
         sv->add(s);
      }
   }
 
   if (0) {
      // print accumulated schema
      printf("read_table_and_event_names:\n");
      sv->print(false);
   }
 
   status = ReadMysqlTableNames(fSql, sv, NULL, fDebug, NULL, NULL);
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

update_column()

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

virtual

Implements SqlHistoryBase.

Definition at line 5974 of file history_schema.cxx.

{
   if (fDebug)
      printf("MysqlHistory::update_column: event [%s], table [%s], column [%s], type [%s] new name [%s], timestamp %s\n", event_name, table_name, column_name, column_type, tag_name, TimeToString(timestamp).c_str());
 
   std::string cmd;
   cmd += "INSERT INTO _history_index (event_name, table_name, tag_name, tag_type, column_name, column_type, itimestamp, active) VALUES (";
   cmd += fSql->QuoteString(event_name);
   cmd += ", ";
   cmd += fSql->QuoteString(table_name);
   cmd += ", ";
   cmd += fSql->QuoteString(tag_name);
   cmd += ", ";
   cmd += fSql->QuoteString(tag_type);
   cmd += ", ";
   cmd += fSql->QuoteString(column_name);
   cmd += ", ";
   cmd += fSql->QuoteString(column_type);
   cmd += ", ";
   char buf[256];
   sprintf(buf, "%.0f", (double)timestamp);
   cmd += fSql->QuoteString(buf);
   cmd += ", ";
   if (active)
      cmd += fSql->QuoteString("1");
   else
      cmd += fSql->QuoteString("0");
   cmd += ");";
         
   int status = fSql->Exec(table_name, cmd.c_str());
   if (status != DB_SUCCESS)
      return HS_FILE_ERROR;
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

---

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

• src/history_schema.cxx