history_schema.cxx File Reference

#include "midas.h"
#include "msystem.h"
#include "mstrlcpy.h"
#include <math.h>
#include <vector>
#include <list>
#include <string>
#include <map>
#include <algorithm>
#include "history.h"

Include dependency graph for history_schema.cxx:

Go to the source code of this file.

Classes
struct	HsSchemaEntry
class	HsSchema
class	HsSchemaVector
class	SqlBase
class	HsSqlSchema
class	HsFileSchema
class	SchemaHistoryBase
class	SchemaHistoryBase::ReadBuffer
class	SqlHistoryBase
class	SqliteHistory
class	MysqlHistory
class	FileHistory

Macros
#define	FREE(x)   { if (x) free(x); (x) = NULL; }

Functions
static char *	skip_spaces (char *s)
static std::string	TimeToString (time_t t)
static std::string	SmallIntToString (int i)
static bool	MatchEventName (const char *event_name, const char *var_event_name)
static bool	MatchTagName (const char *tag_name, int n_data, const char *var_tag_name, const int var_tag_index)
static void	PrintTags (int ntags, const TAG tags[])
static std::string	MidasNameToSqlName (const char *s)
static std::string	MidasNameToFileName (const char *s)
static int	event_name_cmp (const std::string &e1, const char *e2)
static int	var_name_cmp (const std::string &v1, const char *v2)
void	DoctorPgsqlColumnType (std::string *col_type, const char *index_type)
void	DoctorSqlColumnType (std::string *col_type, const char *index_type)
static int	ReadRecord (const char *file_name, int fd, off64_t offset, size_t recsize, off64_t irec, char *rec)
static int	FindTime (const char *file_name, int fd, off64_t offset, size_t recsize, off64_t nrec, time_t timestamp, off64_t *i1p, time_t *t1p, off64_t *i2p, time_t *t2p, time_t *tstart, time_t *tend, int debug)
static HsSqlSchema *	NewSqlSchema (HsSchemaVector *sv, const char *table_name, time_t t)
static int	StartSqlTransaction (SqlBase *sql, const char *table_name, bool *have_transaction)
static int	CreateSqlTable (SqlBase *sql, const char *table_name, bool *have_transaction, bool set_default_timestamp=false)
static int	CreateSqlHyperTable (SqlBase *sql, const char *table_name, bool *have_transaction)
static int	CreateSqlColumn (SqlBase *sql, const char *table_name, const char *column_name, const char *column_type, bool *have_transaction, int debug)
static int	ReadSqliteTableNames (SqlBase *sql, HsSchemaVector *sv, const char *table_name, int debug)
static int	ReadSqliteTableSchema (SqlBase *sql, HsSchemaVector *sv, const char *table_name, int debug)
static int	ReadMysqlTableNames (SqlBase *sql, HsSchemaVector *sv, const char *table_name, int debug, const char *must_have_event_name, const char *must_have_table_name)
MidasHistoryInterface *	MakeMidasHistorySqlite ()
MidasHistoryInterface *	MakeMidasHistoryMysql ()
MidasHistoryInterface *	MakeMidasHistoryPgsql ()
MidasHistoryInterface *	MakeMidasHistoryFile ()

Variables
const time_t	kDay = 24*60*60
const time_t	kMonth = 30*kDay
const double	KiB = 1024
const double	MiB = KiB*KiB

Macro Definition Documentation

FREE

#define FREE

(

x

)

{ if (x) free(x); (x) = NULL; }

Definition at line 53 of file history_schema.cxx.

Function Documentation

CreateSqlColumn()

static int CreateSqlColumn ( SqlBase *  sql, const char *  table_name, const char *  column_name, const char *  column_type, bool *  have_transaction, int  debug  )

static

Definition at line 4746 of file history_schema.cxx.

{
   if (debug)
      printf("CreateSqlColumn: table [%s], column [%s], type [%s]\n", table_name, column_name, column_type);
 
   int status = StartSqlTransaction(sql, table_name, have_transaction);
   if (status != HS_SUCCESS)
      return status;
 
   std::string cmd;
   cmd = "ALTER TABLE ";
   cmd += sql->QuoteId(table_name);
   cmd += " ADD COLUMN ";
   cmd += sql->QuoteId(column_name);
   cmd += " ";
   cmd += column_type;
   cmd += ";";
 
   status = sql->Exec(table_name, cmd.c_str());
 
   cm_msg(MINFO, "CreateSqlColumn", "Adding column \"%s\" to SQL table \"%s\", status %d", column_name, table_name, status);
   cm_msg_flush_buffer();
 
   return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

CreateSqlHyperTable()

static int CreateSqlHyperTable ( SqlBase *  sql, const char *  table_name, bool *  have_transaction  )

static

Definition at line 4672 of file history_schema.cxx.

                                                                                             {
   int status;
 
   status = StartSqlTransaction(sql, table_name, have_transaction);
   if (status != DB_SUCCESS)
      return HS_FILE_ERROR;
 
   std::string cmd;
 
   cmd = "CREATE TABLE ";
   cmd += sql->QuoteId(table_name);
   cmd += " (_t_time TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP, _i_time INTEGER NOT NULL DEFAULT 0);";
 
   status = sql->Exec(table_name, cmd.c_str());
 
   if (status == DB_KEY_EXIST) {
      cm_msg(MINFO, "CreateSqlHyperTable", "Adding SQL table \"%s\", but it already exists", table_name);
      cm_msg_flush_buffer();
      return status;
   }
 
   if (status != DB_SUCCESS) {
      cm_msg(MINFO, "CreateSqlHyperTable", "Adding SQL table \"%s\", error status %d", table_name, status);
      cm_msg_flush_buffer();
      return HS_FILE_ERROR;
   }
 
   cm_msg(MINFO, "CreateSqlHyperTable", "Adding SQL table \"%s\"", table_name);
   cm_msg_flush_buffer();
 
   cmd = "SELECT create_hypertable(";
   cmd += sql->QuoteString(table_name);
   cmd += ", '_t_time');";
   
   // convert regular table to hypertable
   status = sql->Exec(table_name, cmd.c_str());
 
   if (status != DB_SUCCESS) {
      cm_msg(MINFO, "CreateSqlHyperTable", "Converting SQL table to hypertable \"%s\", error status %d", table_name, status);
      cm_msg_flush_buffer();
      return HS_FILE_ERROR;
   }
 
   std::string i_index_name;
   i_index_name = table_name;
   i_index_name += "_i_time_index";
 
   std::string t_index_name;
   t_index_name = table_name;
   t_index_name += "_t_time_index";
 
   cmd = "CREATE INDEX ";
   cmd += sql->QuoteId(i_index_name.c_str());
   cmd += " ON ";
   cmd += sql->QuoteId(table_name);
   cmd += " (_i_time ASC);";
 
   status = sql->Exec(table_name, cmd.c_str());
   if (status != DB_SUCCESS)
      return HS_FILE_ERROR;
 
   cmd = "CREATE INDEX ";
   cmd += sql->QuoteId(t_index_name.c_str());
   cmd += " ON ";
   cmd += sql->QuoteId(table_name);
   cmd += " (_t_time);";
 
   status = sql->Exec(table_name, cmd.c_str());
   if (status != DB_SUCCESS)
      return HS_FILE_ERROR;
 
   return status;
}

Here is the call graph for this function:

CreateSqlTable()

static int CreateSqlTable ( SqlBase *  sql, const char *  table_name, bool *  have_transaction, bool  set_default_timestamp = false  )

static

Definition at line 4605 of file history_schema.cxx.

{
   int status;
 
   status = StartSqlTransaction(sql, table_name, have_transaction);
   if (status != DB_SUCCESS)
      return HS_FILE_ERROR;
 
   std::string cmd;
 
   cmd = "CREATE TABLE ";
   cmd += sql->QuoteId(table_name);
   if (set_default_timestamp) {
      cmd += " (_t_time TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, _i_time INTEGER NOT NULL DEFAULT 0);";
   } else {
      cmd += " (_t_time TIMESTAMP NOT NULL, _i_time INTEGER NOT NULL);";
   }
 
   status = sql->Exec(table_name, cmd.c_str());
 
 
   if (status == DB_KEY_EXIST) {
      cm_msg(MINFO, "CreateSqlTable", "Adding SQL table \"%s\", but it already exists", table_name);
      cm_msg_flush_buffer();
      return status;
   }
 
   if (status != DB_SUCCESS) {
      cm_msg(MINFO, "CreateSqlTable", "Adding SQL table \"%s\", error status %d", table_name, status);
      cm_msg_flush_buffer();
      return HS_FILE_ERROR;
   }
 
   cm_msg(MINFO, "CreateSqlTable", "Adding SQL table \"%s\"", table_name);
   cm_msg_flush_buffer();
 
   std::string i_index_name;
   i_index_name = table_name;
   i_index_name += "_i_time_index";
 
   std::string t_index_name;
   t_index_name = table_name;
   t_index_name += "_t_time_index";
 
   cmd = "CREATE INDEX ";
   cmd += sql->QuoteId(i_index_name.c_str());
   cmd += " ON ";
   cmd += sql->QuoteId(table_name);
   cmd += " (_i_time ASC);";
 
   status = sql->Exec(table_name, cmd.c_str());
   if (status != DB_SUCCESS)
      return HS_FILE_ERROR;
 
   cmd = "CREATE INDEX ";
   cmd += sql->QuoteId(t_index_name.c_str());
   cmd += " ON ";
   cmd += sql->QuoteId(table_name);
   cmd += " (_t_time);";
 
   status = sql->Exec(table_name, cmd.c_str());
   if (status != DB_SUCCESS)
      return HS_FILE_ERROR;
 
   return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

DoctorPgsqlColumnType()

void DoctorPgsqlColumnType	(	std::string *	col_type,
		const char *	index_type
	)

Definition at line 300 of file history_schema.cxx.

{
   if (*col_type == index_type)
      return;
 
   if (*col_type == "bigint" && strcmp(index_type, "int8")==0) {
      *col_type = index_type;
      return;
   }
 
   if (*col_type == "integer" && strcmp(index_type, "int4")==0) {
      *col_type = index_type;
      return;
   }
 
   if (*col_type == "smallint" && strcmp(index_type, "int2")==0) {
      *col_type = index_type;
      return;
   }
 
   cm_msg(MERROR, "SqlHistory", "Cannot use this SQL database, incompatible column names: created column type [%s] is reported with column type [%s]", index_type, col_type->c_str());
   cm_msg_flush_buffer();
   abort();
}

Here is the call graph for this function:

DoctorSqlColumnType()

void DoctorSqlColumnType	(	std::string *	col_type,
		const char *	index_type
	)

Definition at line 325 of file history_schema.cxx.

{
   if (*col_type == index_type)
      return;
 
   if (*col_type == "int(10) unsigned" && strcmp(index_type, "integer unsigned")==0) {
      *col_type = index_type;
      return;
   }
 
   if (*col_type == "int(11)" && strcmp(index_type, "integer")==0) {
      *col_type = index_type;
      return;
   }
 
   if (*col_type == "integer" && strcmp(index_type, "int(11)")==0) {
      *col_type = index_type;
      return;
   }
 
   // MYSQL 8.0.23
 
   if (*col_type == "int" && strcmp(index_type, "integer")==0) {
      *col_type = index_type;
      return;
   }
 
   if (*col_type == "int unsigned" && strcmp(index_type, "integer unsigned")==0) {
      *col_type = index_type;
      return;
   }
 
   cm_msg(MERROR, "SqlHistory", "Cannot use this SQL database, incompatible column names: created column type [%s] is reported with column type [%s]", index_type, col_type->c_str());
   cm_msg_flush_buffer();
   abort();
}

Here is the call graph for this function:

Here is the caller graph for this function:

event_name_cmp()

static int event_name_cmp ( const std::string &  e1, const char *  e2  )

static

Definition at line 218 of file history_schema.cxx.

{
   return strcasecmp(e1.c_str(), e2);
}

Here is the call graph for this function:

Here is the caller graph for this function:

FindTime()

static int FindTime ( const char *  file_name, int  fd, off64_t  offset, size_t  recsize, off64_t  nrec, time_t  timestamp, off64_t *  i1p, time_t *  t1p, off64_t *  i2p, time_t *  t2p, time_t *  tstart, time_t *  tend, int  debug  )

static

Definition at line 2623 of file history_schema.cxx.

{
   //
   // purpose: find location time timestamp inside given file.
   // uses binary search
   // returns:
   // tstart, tend - time of first and last data in a file
   // i1p,t1p - data just before timestamp, used as "last_written"
   // i2p,t2p - data at timestamp or after timestamp, used as starting point to read data from file
   // assertions:
   // tstart <= t1p < t2p <= tend
   // i1p+1==i2p
   // t1p < timestamp <= t2p
   //
   // special cases:
   // 1) timestamp <= tstart - all data is in the future, return i1p==-1, t1p==-1, i2p==0, t2p==tstart
   // 2) tend < timestamp - all the data is in the past, return i1p = nrec-1, t1p = tend, i2p = nrec, t2p = 0;
   // 3) nrec == 1 only one record in this file and it is older than the timestamp (tstart == tend < timestamp)
   //
 
   int status;
   char* buf = new char[recsize];
 
   assert(nrec > 0);
 
   off64_t rec1 = 0;
   off64_t rec2 = nrec-1;
 
   status = ReadRecord(file_name, fd, offset, recsize, rec1, buf);
   if (status != HS_SUCCESS) {
      delete[] buf;
      return HS_FILE_ERROR;
   }
 
   time_t t1 = *(DWORD*)buf;
 
   *tstart = t1;
 
   // timestamp is older than any data in this file
   if (timestamp <= t1) {
      *i1p    = -1;
      *t1p    =  0;
      *i2p    = 0;
      *t2p    = t1;
      *tend   = 0;
      delete[] buf;
      return HS_SUCCESS;
   }
 
   assert(t1 < timestamp);
 
   if (nrec == 1) {
      *i1p    = 0;
      *t1p    = t1;
      *i2p    = nrec; // == 1
      *t2p    = 0;
      *tend   = t1;
      delete[] buf;
      return HS_SUCCESS;
   }
 
   status = ReadRecord(file_name, fd, offset, recsize, rec2, buf);
   if (status != HS_SUCCESS) {
      delete[] buf;
      return HS_FILE_ERROR;
   }
 
   time_t t2 = *(DWORD*)buf;
 
   *tend = t2;
 
   // all the data is in the past
   if (t2 < timestamp) {
      *i1p = rec2;
      *t1p = t2;
      *i2p = nrec;
      *t2p = 0;
      delete[] buf;
      return HS_SUCCESS;
   }
 
   assert(t1 < timestamp);
   assert(timestamp <= t2);
 
   if (debug)
      printf("FindTime: rec %jd..(x)..%jd, time %s..(%s)..%s\n", (intmax_t)rec1, (intmax_t)rec2, TimeToString(t1).c_str(), TimeToString(timestamp).c_str(), TimeToString(t2).c_str());
 
   // implement binary search
 
   do {
      off64_t rec = (rec1+rec2)/2;
 
      assert(rec >= 0);
      assert(rec < nrec);
 
      status = ReadRecord(file_name, fd, offset, recsize, rec, buf);
      if (status != HS_SUCCESS) {
         delete[] buf;
         return HS_FILE_ERROR;
      }
 
      time_t t = *(DWORD*)buf;
 
      if (timestamp <= t) {
         if (debug)
            printf("FindTime: rec %jd..(x)..%jd..%jd, time %s..(%s)..%s..%s\n", (intmax_t)rec1, (intmax_t)rec, (intmax_t)rec2, TimeToString(t1).c_str(), TimeToString(timestamp).c_str(), TimeToString(t).c_str(), TimeToString(t2).c_str());
 
         rec2 = rec;
         t2 = t;
      } else {
         if (debug)
            printf("FindTime: rec %jd..%jd..(x)..%jd, time %s..%s..(%s)..%s\n", (intmax_t)rec1, (intmax_t)rec, (intmax_t)rec2, TimeToString(t1).c_str(), TimeToString(t).c_str(), TimeToString(timestamp).c_str(), TimeToString(t2).c_str());
 
         rec1 = rec;
         t1 = t;
      }
   } while (rec2 - rec1 > 1);
 
   assert(rec1+1 == rec2);
   assert(t1 < timestamp);
   assert(timestamp <= t2);
 
   if (debug)
      printf("FindTime: rec %jd..(x)..%jd, time %s..(%s)..%s, this is the result.\n", (intmax_t)rec1, (intmax_t)rec2, TimeToString(t1).c_str(), TimeToString(timestamp).c_str(), TimeToString(t2).c_str());
 
   *i1p = rec1;
   *t1p = t1;
 
   *i2p = rec2;
   *t2p = t2;
 
   delete[] buf;
   return HS_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

MakeMidasHistoryFile()

MidasHistoryInterface * MakeMidasHistoryFile

(

)

Definition at line 7278 of file history_schema.cxx.

{
   return new FileHistory();
}

Here is the caller graph for this function:

MakeMidasHistoryMysql()

MidasHistoryInterface * MakeMidasHistoryMysql

(

)

Definition at line 7258 of file history_schema.cxx.

{
#ifdef HAVE_MYSQL
   return new MysqlHistory();
#else
   cm_msg(MERROR, "MakeMidasHistoryMysql", "Error: Cannot initialize MySQL history - this MIDAS was built without MySQL support - HAVE_MYSQL is not defined");
   return NULL;
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

MakeMidasHistoryPgsql()

MidasHistoryInterface * MakeMidasHistoryPgsql

(

)

Definition at line 7268 of file history_schema.cxx.

{
#ifdef HAVE_PGSQL
   return new PgsqlHistory();
#else
   cm_msg(MERROR, "MakeMidasHistoryPgsql", "Error: Cannot initialize PgSQL history - this MIDAS was built without PostgreSQL support - HAVE_PGSQL is not defined");
   return NULL;
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

MakeMidasHistorySqlite()

MidasHistoryInterface * MakeMidasHistorySqlite

(

)

Definition at line 7248 of file history_schema.cxx.

{
#ifdef HAVE_SQLITE
   return new SqliteHistory();
#else
   cm_msg(MERROR, "MakeMidasHistorySqlite", "Error: Cannot initialize SQLITE history - this MIDAS was built without SQLITE support - HAVE_SQLITE is not defined");
   return NULL;
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

MatchEventName()

static bool MatchEventName ( const char *  event_name, const char *  var_event_name  )

static

Definition at line 116 of file history_schema.cxx.

{
   // new-style event name: "equipment_name/variable_name:tag_name"
   // old-style event name: "equipment_name:tag_name" ("variable_name" is missing)
   bool newStyleEventName = (strchr(var_event_name, '/')!=NULL);
 
   //printf("looking for event_name [%s], try table [%s] event name [%s], new style [%d]\n", var_event_name, table_name, event_name, newStyleEventName);
 
   if (strcasecmp(event_name, var_event_name) == 0) {
      return true;
   } else if (newStyleEventName) {
      return false;
   } else { // for old style names, need more parsing
      bool match = false;
 
      const char* s = event_name;
      for (int j=0; s[j]; j++) {
 
         if ((var_event_name[j]==0) && (s[j]=='/')) {
            match = true;
            break;
         }
 
         if ((var_event_name[j]==0) && (s[j]=='_')) {
            match = true;
            break;
         }
 
         if (var_event_name[j]==0) {
            match = false;
            break;
         }
 
         if (tolower(var_event_name[j]) != tolower(s[j])) { // does not work for UTF-8 Unicode
            match = false;
            break;
         }
      }
 
      return match;
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

MatchTagName()

static bool MatchTagName ( const char *  tag_name, int  n_data, const char *  var_tag_name, const int  var_tag_index  )

static

Definition at line 159 of file history_schema.cxx.

{
   char alt_tag_name[1024]; // maybe this is an array without "Names"?
   sprintf(alt_tag_name, "%s[%d]", var_tag_name, var_tag_index);
 
   //printf("  looking for tag [%s] alt [%s], try column name [%s]\n", var_tag_name, alt_tag_name, tag_name);
 
   if (strcasecmp(tag_name, var_tag_name) == 0)
      if (var_tag_index >= 0 && var_tag_index < n_data)
         return true;
 
   if (strcasecmp(tag_name, alt_tag_name) == 0)
      return true;
 
   return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

MidasNameToFileName()

static std::string MidasNameToFileName ( const char *  s )

static

Definition at line 201 of file history_schema.cxx.

{
   std::string out;
 
   for (int i=0; s[i]!=0; i++) {
      char c = s[i];
      if (isalpha(c) || isdigit(c))
         out += tolower(c); // does not work for UTF-8 Unicode
      else
         out += '_';
   }
 
   return out;
}

Here is the call graph for this function:

Here is the caller graph for this function:

MidasNameToSqlName()

static std::string MidasNameToSqlName ( const char *  s )

static

Definition at line 184 of file history_schema.cxx.

{
   std::string out;
 
   for (int i=0; s[i]!=0; i++) {
      char c = s[i];
      if (isalpha(c) || isdigit(c))
         out += tolower(c); // does not work for UTF-8 Unicode
      else
         out += '_';
   }
 
   return out;
}

Here is the call graph for this function:

Here is the caller graph for this function:

NewSqlSchema()

static HsSqlSchema * NewSqlSchema ( HsSchemaVector *  sv, const char *  table_name, time_t  t  )

static

Definition at line 4154 of file history_schema.cxx.

{
   time_t tt = 0;
   int j=-1;
   int jjx=-1; // remember oldest schema
   time_t ttx = 0;
   for (size_t i=0; i<sv->size(); i++) {
      HsSqlSchema* s = (HsSqlSchema*)(*sv)[i];
      if (s->fTableName != table_name)
         continue;
 
      if (s->fTimeFrom == t) {
         return s;
      }
 
      // remember the last schema before time t
      if (s->fTimeFrom < t) {
         if (s->fTimeFrom > tt) {
            tt = s->fTimeFrom;
            j = i;
         }
      }
 
      if (jjx < 0) {
         jjx = i;
         ttx = s->fTimeFrom;
      }
 
      if (s->fTimeFrom < ttx) {
         jjx = i;
         ttx = s->fTimeFrom;
      }
 
      //printf("table_name [%s], t=%s, i=%d, j=%d %s, tt=%s, dt is %d\n", table_name, TimeToString(t).c_str(), i, j, TimeToString(s->fTimeFrom).c_str(), TimeToString(tt).c_str(), (int)(s->fTimeFrom-t));
   }
 
   //printf("NewSqlSchema: will copy schema j=%d, tt=%d at time %d\n", j, tt, t);
 
   //printf("cloned schema at time %s: ", TimeToString(t).c_str());
   //(*sv)[j]->print(false);
 
   //printf("schema before:\n");
   //sv->print(false);
 
   if (j >= 0) {
      HsSqlSchema* s = new HsSqlSchema;
      *s = *(HsSqlSchema*)(*sv)[j]; // make a copy
      s->fTimeFrom = t;
      sv->add(s);
 
      //printf("schema after:\n");
      //sv->print(false);
 
      return s;
   }
 
   if (jjx >= 0) {
      cm_msg(MERROR, "NewSqlSchema", "Error: Unexpected ordering of schema for table \'%s\', good luck!", table_name);
 
      HsSqlSchema* s = new HsSqlSchema;
      *s = *(HsSqlSchema*)(*sv)[jjx]; // make a copy
      s->fTimeFrom = t;
      s->fTimeTo = ttx;
      sv->add(s);
 
      //printf("schema after:\n");
      //sv->print(false);
 
      return s;
   }
 
   cm_msg(MERROR, "NewSqlSchema", "Error: Cannot clone schema for table \'%s\', good luck!", table_name);
   return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PrintTags()

static void PrintTags ( int  ntags, const TAG  tags[]  )

static

Definition at line 176 of file history_schema.cxx.

{
   for (int i=0; i<ntags; i++)
      printf("tag %d: %s %s[%d]\n", i, rpc_tid_name(tags[i].type), tags[i].name, tags[i].n_data);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ReadMysqlTableNames()

static int ReadMysqlTableNames ( SqlBase *  sql, HsSchemaVector *  sv, const char *  table_name, int  debug, const char *  must_have_event_name, const char *  must_have_table_name  )

static

Definition at line 5586 of file history_schema.cxx.

{
   if (debug)
      printf("ReadMysqlTableNames: table [%s], must have event [%s] table [%s]\n", table_name, must_have_event_name, must_have_table_name);
 
   int status;
   std::string cmd;
 
   if (table_name) {
      cmd = "SELECT event_name, table_name, itimestamp FROM _history_index WHERE table_name='";
      cmd += table_name;
      cmd += "';";
   } else {
      cmd = "SELECT event_name, table_name, itimestamp FROM _history_index WHERE table_name!='';";
      table_name = "_history_index";
   }
 
   status = sql->Prepare(table_name, cmd.c_str());
 
   if (status != DB_SUCCESS)
      return status;
 
   bool found_must_have_table = false;
   int count = 0;
 
   while (1) {
      status = sql->Step();
 
      if (status != DB_SUCCESS)
         break;
 
      const char* xevent_name  = sql->GetText(0);
      const char* xtable_name  = sql->GetText(1);
      time_t      xevent_time  = sql->GetTime(2);
 
      if (debug == 999) {
         printf("entry %d event name [%s] table name [%s] time %s\n", count, xevent_name, xtable_name, TimeToString(xevent_time).c_str());
      }
 
      if (must_have_table_name && (strcmp(xtable_name, must_have_table_name) == 0)) {
         assert(must_have_event_name != NULL);
         if (event_name_cmp(xevent_name, must_have_event_name) == 0) {
            found_must_have_table = true;
            //printf("Found table [%s]: event name [%s] table name [%s] time %s\n", must_have_table_name, xevent_name, xtable_name, TimeToString(xevent_time).c_str());
         } else {
            //printf("Found correct table [%s] with wrong event name [%s] expected [%s] time %s\n", must_have_table_name, xevent_name, must_have_event_name, TimeToString(xevent_time).c_str());
         }
      }
      
      HsSqlSchema* s = new HsSqlSchema;
      s->fSql = sql;
      s->fEventName = xevent_name;
      s->fTimeFrom = xevent_time;
      s->fTimeTo = 0;
      s->fTableName = xtable_name;
      sv->add(s);
      count++;
   }
 
   status = sql->Finalize();
 
   if (must_have_table_name && !found_must_have_table) {
      cm_msg(MERROR, "ReadMysqlTableNames", "Error: Table [%s] for event [%s] missing from the history index\n", must_have_table_name, must_have_event_name);
      if (debug == 999)
         return HS_FILE_ERROR;
      // NB: recursion is broken by setting debug to 999.
      ReadMysqlTableNames(sql, sv, table_name, 999, must_have_event_name, must_have_table_name);
      cm_msg(MERROR, "ReadMysqlTableNames", "Error: Cannot continue, nothing will work after this error\n");
      cm_msg_flush_buffer();
      abort();
      return HS_FILE_ERROR;
   }
 
   if (0) {
      // print accumulated schema
      printf("ReadMysqlTableNames: table_name [%s] event_name [%s] table_name [%s]\n", table_name, must_have_event_name, must_have_table_name);
      sv->print(false);
   }
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ReadRecord()

static int ReadRecord ( const char *  file_name, int  fd, off64_t  offset, size_t  recsize, off64_t  irec, char *  rec  )

static

Definition at line 2592 of file history_schema.cxx.

{
   off64_t fpos = offset + irec*recsize;
 
   off64_t status64 = ::lseek64(fd, fpos, SEEK_SET);
 
   if (status64 < 0) {
      cm_msg(MERROR, "FileHistory::ReadRecord", "Cannot read \'%s\', lseek64(%jd) errno %d (%s)", file_name, (intmax_t)fpos, errno, strerror(errno));
      return -1;
   }
 
   ssize_t rd = ::read(fd, rec, recsize);
 
   if (rd < 0) {
      cm_msg(MERROR, "FileHistory::ReadRecord", "Cannot read \'%s\', read() errno %d (%s)", file_name, errno, strerror(errno));
      return -1;
   }
 
   if (rd == 0) {
      cm_msg(MERROR, "FileHistory::ReadRecord", "Cannot read \'%s\', unexpected end of file on read()", file_name);
      return -1;
   }
 
   if ((size_t)rd != recsize) {
      cm_msg(MERROR, "FileHistory::ReadRecord", "Cannot read \'%s\', short read() returned %zd instead of %zu bytes", file_name, rd, recsize);
      return -1;
   }
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ReadSqliteTableNames()

static int ReadSqliteTableNames ( SqlBase *  sql, HsSchemaVector *  sv, const char *  table_name, int  debug  )

static

Definition at line 5236 of file history_schema.cxx.

{
   if (debug)
      printf("ReadSqliteTableNames: table [%s]\n", table_name);
 
   int status;
   std::string cmd;
 
   // FIXME: quotes
   cmd = "SELECT event_name, _i_time FROM \'_event_name_";
   cmd += table_name;
   cmd += "\' WHERE table_name='";
   cmd += table_name;
   cmd += "';";
 
   status = sql->Prepare(table_name, cmd.c_str());
 
   if (status != DB_SUCCESS)
      return status;
 
   while (1) {
      status = sql->Step();
 
      if (status != DB_SUCCESS)
         break;
 
      std::string xevent_name  = sql->GetText(0);
      time_t      xevent_time  = sql->GetTime(1);
 
      //printf("read event name [%s] time %s\n", xevent_name.c_str(), TimeToString(xevent_time).c_str());
 
      HsSqlSchema* s = new HsSqlSchema;
      s->fSql = sql;
      s->fEventName = xevent_name;
      s->fTimeFrom = xevent_time;
      s->fTimeTo = 0;
      s->fTableName = table_name;
      sv->add(s);
   }
 
   status = sql->Finalize();
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ReadSqliteTableSchema()

static int ReadSqliteTableSchema ( SqlBase *  sql, HsSchemaVector *  sv, const char *  table_name, int  debug  )

static

Definition at line 5281 of file history_schema.cxx.

{
   if (debug)
      printf("ReadSqliteTableSchema: table [%s]\n", table_name);
 
   if (1) {
      // seed schema with table names
      HsSqlSchema* s = new HsSqlSchema;
      s->fSql = sql;
      s->fEventName = table_name;
      s->fTimeFrom = 0;
      s->fTimeTo = 0;
      s->fTableName = table_name;
      sv->add(s);
   }
 
   return ReadSqliteTableNames(sql, sv, table_name, debug);
}

Here is the call graph for this function:

Here is the caller graph for this function:

skip_spaces()

static char * skip_spaces ( char *  s )

static

Definition at line 55 of file history_schema.cxx.

{
   while (*s) {
      if (!isspace(*s))
         break;
      s++;
   }
   return s;
}

Here is the call graph for this function:

SmallIntToString()

static std::string SmallIntToString ( int  i )

static

Definition at line 95 of file history_schema.cxx.

{
   //int ii = i;
 
   if (i == 0)
      return "0";
 
   assert(i > 0);
 
   std::string v;
   while (i) {
      char c = '0' + (char)(i%10);
      i /= 10;
      v = c + v;
   }
 
   //printf("SmallIntToString: %d -> %s\n", ii, v.c_str());
 
   return v;
}

Here is the call graph for this function:

Here is the caller graph for this function:

StartSqlTransaction()

static int StartSqlTransaction ( SqlBase *  sql, const char *  table_name, bool *  have_transaction  )

static

Definition at line 4592 of file history_schema.cxx.

{
   if (*have_transaction)
      return HS_SUCCESS;
 
   int status = sql->OpenTransaction(table_name);
   if (status != DB_SUCCESS)
      return HS_FILE_ERROR;
 
   *have_transaction = true;
   return HS_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

TimeToString()

static std::string TimeToString ( time_t  t )

static

Definition at line 65 of file history_schema.cxx.

{
   const char* sign = "";
 
   if (t == 0)
      return "0";
 
   time_t tt = t;
 
   if (t < 0) {
      sign = "-";
      tt = -t;
   }
 
   assert(tt > 0);
 
   std::string v;
   while (tt) {
      char c = '0' + (char)(tt%10);
      tt /= 10;
      v = c + v;
   }
 
   v = sign + v;
 
   //printf("time %.0f -> %s\n", (double)t, v.c_str());
 
   return v;
}

Here is the call graph for this function:

Here is the caller graph for this function:

var_name_cmp()

static int var_name_cmp ( const std::string &  v1, const char *  v2  )

static

Definition at line 225 of file history_schema.cxx.

{
   return strcasecmp(v1.c_str(), v2);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

kDay

const time_t kDay = 24*60*60

Definition at line 6442 of file history_schema.cxx.

KiB

const double KiB = 1024

Definition at line 6445 of file history_schema.cxx.

kMonth

const time_t kMonth = 30*kDay

Definition at line 6443 of file history_schema.cxx.

MiB

const double MiB = KiB*KiB

Definition at line 6446 of file history_schema.cxx.