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

Include dependency graph for history_schema.cxx:

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 = 246060

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 54 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 4771 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 4697 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 4630 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 301 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 326 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 219 of file history_schema.cxx.

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

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 2646 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 7296 of file history_schema.cxx.

{
   return new FileHistory();
}

Here is the caller graph for this function:

◆ MakeMidasHistoryMysql()

MidasHistoryInterface * MakeMidasHistoryMysql ( )

Definition at line 7276 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 7286 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 7266 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 117 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 160 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 caller graph for this function:

◆ MidasNameToFileName()

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

static

Definition at line 202 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 caller graph for this function:

◆ MidasNameToSqlName()

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

static

Definition at line 185 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 caller graph for this function:

◆ NewSqlSchema()

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

static

Definition at line 4179 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 177 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 5604 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 {
      // Only enumerate the table-marker rows (one per table/version), not the far more
      // numerous per-column rows. Both carry a non-empty table_name, but the table-marker
      // INSERT omits column_name (leaving it NULL) while the column-record INSERT sets it.
      // Restricting to column_name IS NULL keeps the reader schema vector at ~(#tables)
      // instead of ~(#columns x #versions), which is what blows up on a large _history_index.
      cmd = "SELECT event_name, table_name, itimestamp FROM _history_index WHERE table_name!='' AND column_name IS NULL;";
      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 2615 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 5261 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 5306 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 56 of file history_schema.cxx.

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

◆ SmallIntToString()

static std::string SmallIntToString ( int i )

static

Definition at line 96 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 caller graph for this function:

◆ StartSqlTransaction()

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

static

Definition at line 4617 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 66 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 caller graph for this function:

◆ var_name_cmp()

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

static

Definition at line 226 of file history_schema.cxx.

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

Here is the caller graph for this function:

Variable Documentation

◆ kDay

const time_t kDay = 24*60*60

Definition at line 6456 of file history_schema.cxx.

◆ KiB

const double KiB = 1024

Definition at line 6459 of file history_schema.cxx.

◆ kMonth

const time_t kMonth = 30*kDay

Definition at line 6457 of file history_schema.cxx.

◆ MiB

const double MiB = KiB*KiB

Definition at line 6460 of file history_schema.cxx.

Classes

Macros

Functions

Variables

Macro Definition Documentation

◆ FREE

Function Documentation

◆ CreateSqlColumn()

◆ CreateSqlHyperTable()

◆ CreateSqlTable()

◆ DoctorPgsqlColumnType()

◆ DoctorSqlColumnType()

◆ event_name_cmp()

◆ FindTime()

◆ MakeMidasHistoryFile()

◆ MakeMidasHistoryMysql()

◆ MakeMidasHistoryPgsql()

◆ MakeMidasHistorySqlite()

◆ MatchEventName()

◆ MatchTagName()

◆ MidasNameToFileName()

◆ MidasNameToSqlName()

◆ NewSqlSchema()

◆ PrintTags()

◆ ReadMysqlTableNames()

◆ ReadRecord()

◆ ReadSqliteTableNames()

◆ ReadSqliteTableSchema()

◆ skip_spaces()

◆ SmallIntToString()

◆ StartSqlTransaction()

◆ TimeToString()

◆ var_name_cmp()

Variable Documentation

◆ kDay

◆ KiB

◆ kMonth

◆ MiB