SqliteHistory Class Reference

Inheritance diagram for SqliteHistory:

Collaboration diagram for SqliteHistory:

Public Member Functions
	SqliteHistory ()
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 5329 of file history_schema.cxx.

Constructor & Destructor Documentation

SqliteHistory()

SqliteHistory::SqliteHistory ( )

inline

Definition at line 5332 of file history_schema.cxx.

                   { // ctor
#ifdef HAVE_SQLITE
      fSql = new Sqlite();
#endif
   }

Member Function Documentation

create_table()

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

virtual

Implements SqlHistoryBase.

Definition at line 5490 of file history_schema.cxx.

{
   if (fDebug)
      printf("SqliteHistory::create_table: event [%s], timestamp %s\n", event_name, TimeToString(timestamp).c_str());
 
   int status;
   bool have_transaction = false;
   std::string table_name = MidasNameToSqlName(event_name);
 
   // FIXME: what about duplicate table names?
   status = CreateSqlTable(fSql, table_name.c_str(), &have_transaction);
 
   //if (status == DB_KEY_EXIST) {
   //   return ReadSqliteTableSchema(fSql, sv, table_name.c_str(), fDebug);
   //}
 
   if (status != HS_SUCCESS) {
      // FIXME: ???
      // FIXME: at least close or revert the transaction
      return status;
   }
 
   std::string cmd;
 
   std::string en;
   en += "_event_name_";
   en += table_name;
 
   cmd = "CREATE TABLE ";
   cmd += fSql->QuoteId(en.c_str());
   cmd += " (table_name TEXT NOT NULL, event_name TEXT NOT NULL, _i_time INTEGER NOT NULL);";
 
   status = fSql->Exec(table_name.c_str(), cmd.c_str());
 
   cmd = "INSERT INTO ";
   cmd += fSql->QuoteId(en.c_str());
   cmd += " (table_name, event_name, _i_time) VALUES (";
   cmd += fSql->QuoteString(table_name.c_str());
   cmd += ", ";
   cmd += fSql->QuoteString(event_name);
   cmd += ", ";
   cmd += fSql->QuoteString(TimeToString(timestamp).c_str());
   cmd += ");";
 
   status = fSql->Exec(table_name.c_str(), cmd.c_str());
 
   std::string cn;
   cn += "_column_names_";
   cn += table_name;
 
   cmd = "CREATE TABLE ";
   cmd += fSql->QuoteId(cn.c_str());
   cmd += " (table_name TEXT NOT NULL, column_name TEXT NOT NULL, tag_name TEXT NOT NULL, tag_type TEXT NOT NULL, column_type TEXT NOT NULL, _i_time INTEGER NOT NULL);";
 
   status = fSql->Exec(table_name.c_str(), cmd.c_str());
 
   status = fSql->CommitTransaction(table_name.c_str());
   if (status != DB_SUCCESS) {
      return HS_FILE_ERROR;
   }
 
   return ReadSqliteTableSchema(fSql, sv, table_name.c_str(), fDebug);
}

Here is the call graph for this function:

read_column_names()

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

virtual

Implements SqlHistoryBase.

Definition at line 5375 of file history_schema.cxx.

{
   if (fDebug)
      printf("SqliteHistory::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 = (s->find_column_index(cn) >= 0);
 
         //printf("column [%s] sql type [%s]\n", cn.c_str(), ct);
 
         if (!found) {
            HsSchemaEntry se;
            se.name = cn;
            se.type = 0;
            se.n_data = 1;
            se.n_bytes = 0;
            s->fColumnIndexCache[cn] = s->fColumnNames.size();
            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 tn;
   tn += "_column_names_";
   tn += table_name;
   
   std::string cmd;
   cmd = "SELECT column_name, tag_name, tag_type, _i_time FROM ";
   cmd += fSql->QuoteId(tn.c_str());
   cmd += " WHERE table_name=";
   cmd += fSql->QuoteString(table_name);
   cmd += " ORDER BY _i_time ASC;";
 
   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;
 
      // NOTE: SQL "SELECT ORDER BY _i_time ASC" returns data sorted by time
      // in this code we use the data from the last data row
      // so if multiple rows are present, the latest one is used
 
      std::string col_name  = fSql->GetText(0);
      std::string tag_name  = fSql->GetText(1);
      std::string tag_type  = fSql->GetText(2);
      time_t   schema_time  = fSql->GetTime(3);
 
      //printf("read table [%s] column [%s] tag name [%s] time %s\n", table_name, col_name.c_str(), tag_name.c_str(), TimeToString(xxx_time).c_str());
 
      // 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;
 
         //printf("add column to schema %d\n", s->fTimeFrom);
 
         int j = s->find_column_index(col_name);
         if (j < 0)
            continue;
         s->fVariables[j].name = tag_name;
         s->fVariables[j].type = rpc_name_tid(tag_type.c_str());
         s->fVariables[j].n_data = 1;
         s->fVariables[j].n_bytes = rpc_tid_size(s->fVariables[j].type);
      }
   }
 
   status = fSql->Finalize();
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

read_table_and_event_names()

int SqliteHistory::read_table_and_event_names ( HsSchemaVector *  sv )

virtual

Implements SqlHistoryBase.

Definition at line 5344 of file history_schema.cxx.

{
   int status;
 
   if (fDebug)
      printf("SqliteHistory::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, "_event_name_");
      if (s == table_name)
         continue;
      s = strstr(table_name, "_column_names_");
      if (s == table_name)
         continue;
 
      status = ReadSqliteTableSchema(fSql, sv, table_name, fDebug);
   }
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

update_column()

int SqliteHistory::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 5554 of file history_schema.cxx.

{
   if (fDebug)
      printf("SqliteHistory::update_column: event [%s], table [%s], column [%s], new name [%s], timestamp %s\n", event_name, table_name, column_name, tag_name, TimeToString(timestamp).c_str());
 
   int status = StartSqlTransaction(fSql, table_name, have_transaction);
   if (status != HS_SUCCESS)
      return status;
 
   // FIXME: quotes
   std::string cmd;
   cmd = "INSERT INTO \'_column_names_";
   cmd += table_name;
   cmd += "\' (table_name, column_name, tag_name, tag_type, column_type, _i_time) VALUES (\'";
   cmd += table_name;
   cmd += "\', \'";
   cmd += column_name;
   cmd += "\', \'";
   cmd += tag_name;
   cmd += "\', \'";
   cmd += tag_type;
   cmd += "\', \'";
   cmd += column_type;
   cmd += "\', \'";
   cmd += TimeToString(timestamp);
   cmd += "\');";
   status = fSql->Exec(table_name, cmd.c_str());
 
   return status;
}

Here is the call graph for this function:

---

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

• src/history_schema.cxx