HsSqlSchema Struct Reference

Inheritance diagram for HsSqlSchema:

Collaboration diagram for HsSqlSchema:

Public Member Functions
	HsSqlSchema ()
	~HsSqlSchema ()
void	print (bool print_tags=true) const
int	get_transaction_count ()
void	reset_transaction_count ()
void	increment_transaction_count ()
int	close_transaction ()
int	flush_buffers ()
int	close ()
int	write_event (const time_t t, const char *data, const int data_size)
int	match_event_var (const char *event_name, const char *var_name, const int var_index)
int	read_last_written (const time_t timestamp, const int debug, time_t *last_written)
int	read_data (const time_t start_time, const time_t end_time, const int num_var, const std::vector< int > &var_schema_index, const int var_index[], const int debug, std::vector< time_t > &last_time, MidasHistoryBufferInterface *buffer[])
Public Member Functions inherited from HsSchema
	HsSchema ()
virtual	~HsSchema ()

Public Attributes
SqlBase *	sql
std::vector< std::string >	disconnected_buffer
std::string	table_name
std::vector< std::string >	column_names
std::vector< std::string >	column_types
Public Attributes inherited from HsSchema
std::string	event_name
time_t	time_from = 0
time_t	time_to = 0
std::vector< HsSchemaEntry >	variables
std::vector< int >	offsets
int	n_bytes = 0
int	count_write_undersize = 0
int	count_write_oversize = 0
int	write_max_size = 0
int	write_min_size = 0
bool	disabled = true

Private Attributes
int	table_transaction_count

Static Private Attributes
static std::map< SqlBase *, int >	global_transaction_count

Detailed Description

Definition at line 693 of file history_schema.cxx.

Constructor & Destructor Documentation

HsSqlSchema()

HsSqlSchema::HsSqlSchema ( )

inline

Definition at line 700 of file history_schema.cxx.

   {
      sql = 0;
      table_transaction_count = 0;
   }

~HsSqlSchema()

HsSqlSchema::~HsSqlSchema ( )

inline

Definition at line 706 of file history_schema.cxx.

   {
      assert(get_transaction_count() == 0);
   }

Here is the call graph for this function:

Member Function Documentation

close()

int HsSqlSchema::close ( )

inlinevirtual

Implements HsSchema.

Definition at line 717 of file history_schema.cxx.

{ return close_transaction(); }

Here is the call graph for this function:

close_transaction()

int HsSqlSchema::close_transaction

(

)

Definition at line 4027 of file history_schema.cxx.

{
   if (!sql->IsConnected()) {
      return HS_SUCCESS;
   }
   
   int status = HS_SUCCESS;
   if (get_transaction_count() > 0) {
      status = sql->CommitTransaction(table_name.c_str());
      reset_transaction_count();
   }
   return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

flush_buffers()

int HsSqlSchema::flush_buffers ( )

inlinevirtual

Implements HsSchema.

Definition at line 716 of file history_schema.cxx.

{ return close_transaction(); }

Here is the call graph for this function:

get_transaction_count()

int HsSqlSchema::get_transaction_count

(

)

Definition at line 4405 of file history_schema.cxx.

                                       {
   if (!sql || sql->fTransactionPerTable) {
      return table_transaction_count;
   } else {
      return global_transaction_count[sql];
   }
}

Here is the caller graph for this function:

increment_transaction_count()

void HsSqlSchema::increment_transaction_count

(

)

Definition at line 4421 of file history_schema.cxx.

                                              {
   if (!sql || sql->fTransactionPerTable) {
      table_transaction_count++;
   } else {
      global_transaction_count[sql]++;
   }
}

Here is the caller graph for this function:

match_event_var()

int HsSqlSchema::match_event_var ( const char *  event_name, const char *  var_name, const int  var_index  )

virtual

Reimplemented from HsSchema.

Definition at line 4059 of file history_schema.cxx.

{
   if (event_name_cmp(this->table_name, event_name)==0) {
      for (unsigned j=0; j<this->variables.size(); j++) {
         if (var_name_cmp(this->column_names[j], var_name)==0)
            return j;
      }
   }
 
   return HsSchema::match_event_var(event_name, var_name, var_index);
}

Here is the call graph for this function:

print()

void HsSqlSchema::print ( bool  print_tags = true ) const

virtual

Reimplemented from HsSchema.

Definition at line 797 of file history_schema.cxx.

{
   unsigned nv = this->variables.size();
   printf("event [%s], sql_table [%s], time %s..%s, %d variables, %d bytes\n", this->event_name.c_str(), this->table_name.c_str(), TimeToString(this->time_from).c_str(), TimeToString(this->time_to).c_str(), nv, n_bytes);
   if (print_tags) {
      for (unsigned j=0; j<nv; j++) {
         printf("  %d: name [%s], type [%s] tid %d, n_data %d, n_bytes %d", j, this->variables[j].name.c_str(), rpc_tid_name(this->variables[j].type), this->variables[j].type, this->variables[j].n_data, this->variables[j].n_bytes);
         printf(", sql_column [%s], sql_type [%s], offset %d", this->column_names[j].c_str(), this->column_types[j].c_str(), this->offsets[j]);
         printf(", inactive %d", this->variables[j].inactive);
         printf("\n");
      }
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

read_data()

int HsSqlSchema::read_data ( const time_t  start_time, const time_t  end_time, const int  num_var, const std::vector< int > &  var_schema_index, const int  var_index[], const int  debug, std::vector< time_t > &  last_time, MidasHistoryBufferInterface *  buffer[]  )

virtual

Implements HsSchema.

Definition at line 4316 of file history_schema.cxx.

{
   bool bad_last_time = false;
 
   if (debug)
      printf("SqlHistory::read_data: table [%s], start %s, end %s\n", table_name.c_str(), TimeToString(start_time).c_str(), TimeToString(end_time).c_str());
 
   std::string collist;
 
   for (int i=0; i<num_var; i++) {
      int j = var_schema_index[i];
      if (j < 0)
         continue;
      if (collist.length() > 0)
         collist += ", ";
      collist += sql->QuoteId(column_names[j].c_str());
   }
 
   std::string cmd;
   cmd += "SELECT _i_time, ";
   cmd += collist;
   cmd += " FROM ";
   cmd += sql->QuoteId(table_name.c_str());
   cmd += " WHERE _i_time>=";
   cmd += TimeToString(start_time);
   cmd += " and _i_time<=";
   cmd += TimeToString(end_time);
   cmd += " ORDER BY _i_time;";
 
   int status = sql->Prepare(table_name.c_str(), cmd.c_str());
 
   if (status != DB_SUCCESS)
      return HS_FILE_ERROR;
 
   /* Loop through the rows in the result-set */
 
   int count = 0;
 
   while (1) {
      status = sql->Step();
      if (status != DB_SUCCESS)
         break;
 
      count++;
 
      time_t t = sql->GetTime(0);
 
      if (t < start_time || t > end_time)
         continue;
 
      int k = 0;
 
      for (int i=0; i<num_var; i++) {
         int j = var_schema_index[i];
         if (j < 0)
            continue;
 
         if (t < last_time[i]) { // protect against duplicate and non-monotonous data
            bad_last_time = true;
         } else {
            double v = sql->GetDouble(1+k);
 
            //printf("Column %d, index %d, Row %d, time %d, value %f\n", k, colindex[k], count, t, v);
 
            buffer[i]->Add(t, v);
            last_time[i] = t;
         }
 
         k++;
      }
   }
 
   sql->Finalize();
 
   if (bad_last_time) {
      cm_msg(MERROR, "SqlHistory::read_data", "Detected duplicate or non-monotonous data in table \"%s\" for start time %s and end time %s", table_name.c_str(), TimeToString(start_time).c_str(), TimeToString(end_time).c_str());
   }
 
   if (debug)
      printf("SqlHistory::read_data: table [%s], start %s, end %s, read %d rows\n", table_name.c_str(), TimeToString(start_time).c_str(), TimeToString(end_time).c_str(), count);
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

read_last_written()

int HsSqlSchema::read_last_written ( const time_t  timestamp, const int  debug, time_t *  last_written  )

virtual

Implements HsSchema.

Definition at line 4269 of file history_schema.cxx.

{
   if (debug)
      printf("SqlHistory::read_last_written: table [%s], timestamp %s\n", table_name.c_str(), TimeToString(timestamp).c_str());
 
   std::string cmd;
   cmd += "SELECT _i_time FROM ";
   cmd += sql->QuoteId(table_name.c_str());
   cmd += " WHERE _i_time < ";
   cmd += TimeToString(timestamp);
   cmd += " ORDER BY _i_time DESC LIMIT 2;";
 
   int status = sql->Prepare(table_name.c_str(), cmd.c_str());
 
   if (status != DB_SUCCESS)
      return status;
 
   time_t lw = 0;
 
   /* Loop through the rows in the result-set */
 
   while (1) {
      status = sql->Step();
      if (status != DB_SUCCESS)
         break;
 
      time_t t = sql->GetTime(0);
 
      if (t >= timestamp)
         continue;
 
      if (t > lw)
         lw = t;
   }
 
   sql->Finalize();
 
   *last_written = lw;
 
   if (debug)
      printf("SqlHistory::read_last_written: table [%s], timestamp %s, last_written %s\n", table_name.c_str(), TimeToString(timestamp).c_str(), TimeToString(lw).c_str());
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

reset_transaction_count()

void HsSqlSchema::reset_transaction_count

(

)

Definition at line 4413 of file history_schema.cxx.

                                          {
   if (!sql || sql->fTransactionPerTable) {
      table_transaction_count = 0;
   } else {
      global_transaction_count[sql] = 0;
   }
}

Here is the caller graph for this function:

write_event()

int HsSqlSchema::write_event ( const time_t  t, const char *  data, const int  data_size  )

virtual

Implements HsSchema.

Definition at line 4145 of file history_schema.cxx.

{
   HsSqlSchema* s = this;
 
   std::string tags;
   std::string values;
 
   for (unsigned i=0; i<s->variables.size(); i++) {
      if (s->variables[i].inactive)
         continue;
 
      int type   = s->variables[i].type;
      int n_data = s->variables[i].n_data;
      int offset = s->offsets[i];
      const char* column_name = s->column_names[i].c_str();
 
      if (offset < 0)
         continue;
 
      assert(n_data == 1);
      assert(strlen(column_name) > 0);
      assert(offset < data_size);
 
      void* ptr = (void*)(data+offset);
 
      tags += ", ";
      tags += sql->QuoteId(column_name);
 
      values += ", ";
 
      char buf[1024];
      int j=0;
 
      switch (type) {
      default:
         sprintf(buf, "unknownType%d", type);
         break;
      case TID_BYTE:
         sprintf(buf, "%u",((unsigned char *)ptr)[j]);
         break;
      case TID_SBYTE:
         sprintf(buf, "%d",((signed char*)ptr)[j]);
         break;
      case TID_CHAR:
         // FIXME: quotes
         sprintf(buf, "\'%c\'",((char*)ptr)[j]);
         break;
      case TID_WORD:
         sprintf(buf, "%u",((unsigned short *)ptr)[j]);
         break;
      case TID_SHORT:
         sprintf(buf, "%d",((short *)ptr)[j]);
         break;
      case TID_DWORD:
         sprintf(buf, "%u",((unsigned int *)ptr)[j]);
         break;
      case TID_INT:
         sprintf(buf, "%d",((int *)ptr)[j]);
         break;
      case TID_BOOL:
         sprintf(buf, "%u",((unsigned int *)ptr)[j]);
         break;
      case TID_FLOAT:
         // FIXME: quotes
         sprintf(buf, "\'%.8g\'",((float*)ptr)[j]);
         break;
      case TID_DOUBLE:
         // FIXME: quotes
         sprintf(buf, "\'%.16g\'",((double*)ptr)[j]);
         break;
      }
 
      values += buf;
   }
 
   // 2001-02-16 20:38:40.1
   struct tm tms;
   localtime_r(&t, &tms); // somebody must call tzset() before this.
   char buf[1024];
   strftime(buf, sizeof(buf)-1, "%Y-%m-%d %H:%M:%S.0", &tms);
 
   std::string cmd;
   cmd = "INSERT INTO ";
   cmd += sql->QuoteId(s->table_name.c_str());
   cmd += " (_t_time, _i_time";
   cmd += tags;
   cmd += ") VALUES (";
   cmd += sql->QuoteString(buf);
   cmd += ", ";
   cmd += sql->QuoteString(TimeToString(t).c_str());
   cmd += "";
   cmd += values;
   cmd += ");";
 
   if (sql->IsConnected()) {
      if (s->get_transaction_count() == 0)
         sql->OpenTransaction(s->table_name.c_str());
 
      s->increment_transaction_count();
 
      int status = sql->Exec(s->table_name.c_str(), cmd.c_str());
 
      // mh2sql who does not call hs_flush_buffers()
      // so we should flush the transaction by hand
      // some SQL engines have limited transaction buffers... K.O.
      if (s->get_transaction_count() > 100000) {
         //printf("flush table %s\n", table_name);
         sql->CommitTransaction(s->table_name.c_str());
         s->reset_transaction_count();
      }
      
      if (status != DB_SUCCESS) {
         return status;
      }
   } else {
      int status = sql->ExecDisconnected(s->table_name.c_str(), cmd.c_str());
      if (status != DB_SUCCESS) {
         return status;
      }
   }
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

Member Data Documentation

column_names

std::vector<std::string> HsSqlSchema::column_names

Definition at line 697 of file history_schema.cxx.

column_types

std::vector<std::string> HsSqlSchema::column_types

Definition at line 698 of file history_schema.cxx.

disconnected_buffer

std::vector<std::string> HsSqlSchema::disconnected_buffer

Definition at line 695 of file history_schema.cxx.

global_transaction_count

std::map< SqlBase *, int > HsSqlSchema::global_transaction_count

staticprivate

Definition at line 736 of file history_schema.cxx.

sql

SqlBase* HsSqlSchema::sql

Definition at line 694 of file history_schema.cxx.

table_name

std::string HsSqlSchema::table_name

Definition at line 696 of file history_schema.cxx.

table_transaction_count

int HsSqlSchema::table_transaction_count

private

Definition at line 735 of file history_schema.cxx.

---

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

• src/history_schema.cxx