MIDAS
Loading...
Searching...
No Matches
SqlHistoryBase Class Referenceabstract
Inheritance diagram for SqlHistoryBase:
Collaboration diagram for SqlHistoryBase:

Public Member Functions

 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
 
HsSchemanew_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)
 
- 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 ()
 

Public Attributes

SqlBasefSql
 
- Public Attributes inherited from MidasHistoryInterface
char name [NAME_LENGTH]
 
char type [NAME_LENGTH]
 history channel name
 

Protected Member Functions

virtual int read_table_and_event_names (HsSchemaVector *sv)=0
 
virtual int read_column_names (HsSchemaVector *sv, const char *table_name, const char *event_name)=0
 
virtual int create_table (HsSchemaVector *sv, const char *event_name, time_t timestamp)=0
 
virtual 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)=0
 
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)
 

Additional Inherited Members

- Protected Attributes inherited from SchemaHistoryBase
int fDebug
 
std::string fConnectString
 
HsSchemaVector fWriterCurrentSchema
 
std::vector< HsSchema * > fEvents
 
HsSchemaVector fSchema
 

Detailed Description

Definition at line 4687 of file history_schema.cxx.

Constructor & Destructor Documentation

◆ SqlHistoryBase()

SqlHistoryBase::SqlHistoryBase ( )
inline

Definition at line 4692 of file history_schema.cxx.

4693 {
4694 fSql = NULL;
4696 }
int hs_clear_cache()
clear internal cache, returns HS_SUCCESS
TH1X EXPRT * h1_book(const char *name, const char *title, int bins, double min, double max)
Definition rmidas.h:24
Here is the call graph for this function:

◆ ~SqlHistoryBase()

virtual SqlHistoryBase::~SqlHistoryBase ( )
inlinevirtual

Definition at line 4698 of file history_schema.cxx.

4699 {
4700 hs_disconnect();
4701 if (fSql)
4702 delete fSql;
4703 fSql = NULL;
4704 }
int hs_disconnect()
disconnect from history, returns HS_SUCCESS
Here is the call graph for this function:

Member Function Documentation

◆ create_table()

virtual int SqlHistoryBase::create_table ( HsSchemaVector sv,
const char event_name,
time_t  timestamp 
)
protectedpure virtual

Implemented in SqliteHistory, and MysqlHistory.

Here is the caller graph for this function:

◆ hs_connect()

int SqlHistoryBase::hs_connect ( const char connect_string)
virtual

returns HS_SUCCESS

Implements SchemaHistoryBase.

Definition at line 4728 of file history_schema.cxx.

4729{
4730 if (fDebug)
4731 printf("hs_connect [%s]!\n", connect_string);
4732
4733 assert(fSql);
4734
4735 if (fSql->IsConnected())
4736 if (strcmp(fConnectString.c_str(), connect_string) == 0)
4737 return HS_SUCCESS;
4738
4739 hs_disconnect();
4740
4741 if (!connect_string || strlen(connect_string) < 1) {
4742 // FIXME: should use "logger dir" or some such default, that code should be in hs_get_history(), not here
4743 connect_string = ".";
4744 }
4745
4747
4748 if (fDebug)
4749 printf("hs_connect: connecting to SQL database \'%s\'\n", fConnectString.c_str());
4750
4751 int status = fSql->Connect(fConnectString.c_str());
4752 if (status != DB_SUCCESS)
4753 return status;
4754
4755 return HS_SUCCESS;
4756}
virtual bool IsConnected()=0
virtual int Connect(const char *dsn=0)=0
#define DB_SUCCESS
Definition midas.h:631
#define HS_SUCCESS
Definition midas.h:727
DWORD status
Definition odbhist.cxx:39
Here is the call graph for this function:

◆ hs_disconnect()

int SqlHistoryBase::hs_disconnect ( )
virtual

disconnect from history, returns HS_SUCCESS

Implements SchemaHistoryBase.

Definition at line 4758 of file history_schema.cxx.

4759{
4760 if (fDebug)
4761 printf("hs_disconnect!\n");
4762
4764
4765 fSql->Disconnect();
4766
4768
4769 return HS_SUCCESS;
4770}
int hs_flush_buffers()
flush buffered data to storage where it is visible to mhttpd
virtual int Disconnect()=0
Here is the call graph for this function:
Here is the caller graph for this function:

◆ hs_set_debug()

int SqlHistoryBase::hs_set_debug ( int  debug)
inlinevirtual

set debug level, returns previous debug level

Reimplemented from SchemaHistoryBase.

Definition at line 4706 of file history_schema.cxx.

4707 {
4708 if (fSql)
4709 fSql->fDebug = debug;
4711 }
virtual int hs_set_debug(int debug)
set debug level, returns previous debug level
BOOL debug
debug printouts
Definition mana.cxx:254
Here is the call graph for this function:

◆ new_event()

HsSchema * SqlHistoryBase::new_event ( const char event_name,
time_t  timestamp,
int  ntags,
const TAG  tags[] 
)
virtual

Implements SchemaHistoryBase.

Definition at line 4772 of file history_schema.cxx.

4773{
4774 if (fDebug)
4775 printf("SqlHistory::new_event: event [%s], timestamp %s, ntags %d\n", event_name, TimeToString(timestamp).c_str(), ntags);
4776
4777 int status;
4778
4779 if (fWriterCurrentSchema.size() == 0) {
4781 if (status != HS_SUCCESS)
4782 return NULL;
4783 }
4784
4785 HsSqlSchema* s = (HsSqlSchema*)fWriterCurrentSchema.find_event(event_name, timestamp);
4786
4787 // schema does not exist, the SQL tables probably do not exist yet
4788
4789 if (!s) {
4790 status = create_table(&fWriterCurrentSchema, event_name, timestamp);
4791 if (status != HS_SUCCESS)
4792 return NULL;
4793
4794 s = (HsSqlSchema*)fWriterCurrentSchema.find_event(event_name, timestamp);
4795
4796 if (!s) {
4797 cm_msg(MERROR, "SqlHistory::new_event", "Error: Cannot create schema for event \'%s\', see previous messages", event_name);
4798 fWriterCurrentSchema.find_event(event_name, timestamp, 1);
4799 return NULL;
4800 }
4801 }
4802
4803 assert(s != NULL);
4804
4806 if (status != HS_SUCCESS)
4807 return NULL;
4808
4809 s = (HsSqlSchema*)fWriterCurrentSchema.find_event(event_name, timestamp);
4810
4811 if (!s) {
4812 cm_msg(MERROR, "SqlHistory::new_event", "Error: Cannot update schema database for event \'%s\', see previous messages", event_name);
4813 return NULL;
4814 }
4815
4816 if (0||fDebug) {
4817 printf("SqlHistory::new_event: schema for [%s] is %p\n", event_name, s);
4818 if (s)
4819 s->print();
4820 }
4821
4822 status = update_schema(s, timestamp, ntags, tags, true);
4823 if (status != HS_SUCCESS) {
4824 cm_msg(MERROR, "SqlHistory::new_event", "Error: Cannot create schema for event \'%s\', see previous messages", event_name);
4825 return NULL;
4826 }
4827
4829 if (status != HS_SUCCESS)
4830 return NULL;
4831
4832 s = (HsSqlSchema*)fWriterCurrentSchema.find_event(event_name, timestamp);
4833
4834 if (!s) {
4835 cm_msg(MERROR, "SqlHistory::new_event", "Error: Cannot update schema database for event \'%s\', see previous messages", event_name);
4836 return NULL;
4837 }
4838
4839 if (0||fDebug) {
4840 printf("SqlHistory::new_event: schema for [%s] is %p\n", event_name, s);
4841 if (s)
4842 s->print();
4843 }
4844
4845 // last call to UpdateMysqlSchema with "false" will check that new schema matches the new tags
4846
4847 status = update_schema(s, timestamp, ntags, tags, false);
4848 if (status != HS_SUCCESS) {
4849 cm_msg(MERROR, "SqlHistory::new_event", "Error: Cannot create schema for event \'%s\', see previous messages", event_name);
4850 //fDebug = 1;
4851 //update_schema(s, timestamp, ntags, tags, false);
4852 //abort();
4853 return NULL;
4854 }
4855
4856 HsSqlSchema* e = new HsSqlSchema();
4857
4858 *e = *s; // make a copy of the schema
4859
4860 return e;
4861}
std::string fEventName
unsigned size() const
HsSchema * find_event(const char *event_name, const time_t timestamp, int debug=0)
void print(bool print_tags=true) const
std::string fTableName
HsSchemaVector fWriterCurrentSchema
virtual int create_table(HsSchemaVector *sv, const char *event_name, time_t timestamp)=0
virtual int read_column_names(HsSchemaVector *sv, const char *table_name, const char *event_name)=0
virtual int read_table_and_event_names(HsSchemaVector *sv)=0
int update_schema(HsSqlSchema *s, const time_t timestamp, const int ntags, const TAG tags[], bool write_enable)
#define MERROR
Definition midas.h:559
INT cm_msg(INT message_type, const char *filename, INT line, const char *routine, const char *format,...)
Definition midas.cxx:915
static std::string TimeToString(time_t t)
static double e(void)
Definition tinyexpr.c:136
Here is the call graph for this function:

◆ read_column_names()

virtual int SqlHistoryBase::read_column_names ( HsSchemaVector sv,
const char table_name,
const char event_name 
)
protectedpure virtual

Implemented in SqliteHistory, and MysqlHistory.

Here is the caller graph for this function:

◆ read_schema()

int SqlHistoryBase::read_schema ( HsSchemaVector sv,
const char event_name,
const time_t  timestamp 
)
virtual

Implements SchemaHistoryBase.

Definition at line 4863 of file history_schema.cxx.

4864{
4865 if (fDebug)
4866 printf("SqlHistory::read_schema: loading schema for event [%s] at time %s\n", event_name, TimeToString(timestamp).c_str());
4867
4868 int status;
4869
4870 if (fSchema.size() == 0) {
4872 if (status != HS_SUCCESS)
4873 return status;
4874 }
4875
4876 //sv->print(false);
4877
4878 if (event_name == NULL)
4879 return HS_SUCCESS;
4880
4881 for (unsigned i=0; i<sv->size(); i++) {
4882 HsSqlSchema* h = (HsSqlSchema*)(*sv)[i];
4883 // skip schema with already read column names
4884 if (h->fVariables.size() > 0)
4885 continue;
4886 // skip schema with different name
4887 if (!MatchEventName(h->fEventName.c_str(), event_name))
4888 continue;
4889
4890 unsigned nn = sv->size();
4891
4892 status = read_column_names(sv, h->fTableName.c_str(), h->fEventName.c_str());
4893
4894 // if new schema was added, loop all over again
4895 if (sv->size() != nn)
4896 i=0;
4897 }
4898
4899 //sv->print(false);
4900
4901 return HS_SUCCESS;
4902}
std::vector< HsSchemaEntry > fVariables
HsSchemaVector fSchema
static bool MatchEventName(const char *event_name, const char *var_event_name)
INT i
Definition mdump.cxx:32
Here is the call graph for this function:

◆ read_table_and_event_names()

virtual int SqlHistoryBase::read_table_and_event_names ( HsSchemaVector sv)
protectedpure virtual

Implemented in SqliteHistory, and MysqlHistory.

Here is the caller graph for this function:

◆ update_column()

virtual int SqlHistoryBase::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 
)
protectedpure virtual

Implemented in SqliteHistory, and MysqlHistory.

Here is the caller graph for this function:

◆ update_schema()

int SqlHistoryBase::update_schema ( HsSqlSchema s,
const time_t  timestamp,
const int  ntags,
const TAG  tags[],
bool  write_enable 
)
protected

Definition at line 4904 of file history_schema.cxx.

4905{
4906 int status;
4907 bool have_transaction = false;
4908
4909 status = update_schema1(s, timestamp, ntags, tags, write_enable, &have_transaction);
4910
4911 if (have_transaction) {
4912 int xstatus;
4913
4914 if (status == HS_SUCCESS)
4916 else
4918
4919 if (xstatus != DB_SUCCESS) {
4920 return HS_FILE_ERROR;
4921 }
4922 have_transaction = false;
4923 }
4924
4925 return status;
4926}
virtual int RollbackTransaction(const char *table_name)=0
virtual int CommitTransaction(const char *table_name)=0
int update_schema1(HsSqlSchema *s, const time_t timestamp, const int ntags, const TAG tags[], bool write_enable, bool *have_transaction)
#define HS_FILE_ERROR
Definition midas.h:728
Here is the call graph for this function:
Here is the caller graph for this function:

◆ update_schema1()

int SqlHistoryBase::update_schema1 ( HsSqlSchema s,
const time_t  timestamp,
const int  ntags,
const TAG  tags[],
bool  write_enable,
bool have_transaction 
)
protected

Definition at line 4928 of file history_schema.cxx.

4929{
4930 int status;
4931
4932 if (fDebug)
4933 printf("update_schema1\n");
4934
4935 // check that compare schema with tags[]
4936
4937 bool schema_ok = true;
4938
4939 int offset = 0;
4940 for (int i=0; i<ntags; i++) {
4941 for (unsigned int j=0; j<tags[i].n_data; j++) {
4942 int tagtype = tags[i].type;
4943 std::string tagname = tags[i].name;
4944 std::string maybe_colname = MidasNameToSqlName(tags[i].name);
4945
4946 if (tags[i].n_data > 1) {
4947 char s[256];
4948 sprintf(s, "[%d]", j);
4949 tagname += s;
4950
4951 sprintf(s, "_%d", j);
4952 maybe_colname += s;
4953 }
4954
4955 int count = 0;
4956
4957 for (unsigned j=0; j<s->fVariables.size(); j++) {
4958 // NB: inactive columns will be reactivated or recreated by the if(count==0) branch. K.O.
4959 if (s->fColumnInactive[j])
4960 continue;
4961 if (tagname == s->fVariables[j].name) {
4962 if (s->fSql->TypesCompatible(tagtype, s->fColumnTypes[j].c_str())) {
4963 if (count == 0) {
4964 s->fOffsets[j] = offset;
4966 }
4967 count++;
4968 if (count > 1) {
4969 cm_msg(MERROR, "SqlHistory::update_schema", "Duplicate SQL column \'%s\' type \'%s\' in table \"%s\" with MIDAS type \'%s\' history event \"%s\" tag \"%s\"", s->fColumnNames[j].c_str(), s->fColumnTypes[j].c_str(), s->fTableName.c_str(), rpc_tid_name(tagtype), s->fEventName.c_str(), tagname.c_str());
4971 }
4972 } else {
4973 // column with incompatible type, mark it as unused
4974 schema_ok = false;
4975 if (fDebug)
4976 printf("Incompatible column!\n");
4977 if (write_enable) {
4978 cm_msg(MINFO, "SqlHistory::update_schema", "Deactivating SQL column \'%s\' type \'%s\' in table \"%s\" as incompatible with MIDAS type \'%s\' history event \"%s\" tag \"%s\"", s->fColumnNames[j].c_str(), s->fColumnTypes[j].c_str(), s->fTableName.c_str(), rpc_tid_name(tagtype), s->fEventName.c_str(), tagname.c_str());
4980
4981 status = update_column(s->fEventName.c_str(), s->fTableName.c_str(), s->fColumnNames[j].c_str(), s->fColumnTypes[j].c_str(), s->fVariables[j].tag_name.c_str(), s->fVariables[i].tag_type.c_str(), timestamp, false, have_transaction);
4982 if (status != HS_SUCCESS)
4983 return status;
4984 }
4985 }
4986 }
4987 }
4988
4989 if (count == 0) {
4990 // tag does not have a corresponding column
4991 schema_ok = false;
4992 if (fDebug)
4993 printf("No column for tag %s!\n", tagname.c_str());
4994
4995 bool found_column = false;
4996
4997 if (write_enable) {
4998 for (unsigned j=0; j<s->fVariables.size(); j++) {
4999 if (tagname == s->fVariables[j].tag_name) {
5000 bool typeok = s->fSql->TypesCompatible(tagtype, s->fColumnTypes[j].c_str());
5001 if (typeok) {
5002 cm_msg(MINFO, "SqlHistory::update_schema", "Reactivating SQL column \'%s\' type \'%s\' in table \"%s\" for history event \"%s\" tag \"%s\"", s->fColumnNames[j].c_str(), s->fColumnTypes[j].c_str(), s->fTableName.c_str(), s->fEventName.c_str(), tagname.c_str());
5004
5005 status = update_column(s->fEventName.c_str(), s->fTableName.c_str(), s->fColumnNames[j].c_str(), s->fColumnTypes[j].c_str(), s->fVariables[j].tag_name.c_str(), s->fVariables[j].tag_type.c_str(), timestamp, true, have_transaction);
5006 if (status != HS_SUCCESS)
5007 return status;
5008
5009 if (count == 0) {
5010 s->fOffsets[j] = offset;
5012 }
5013 count++;
5014 found_column = true;
5015 if (count > 1) {
5016 cm_msg(MERROR, "SqlHistory::update_schema", "Duplicate SQL column \'%s\' type \'%s\' in table \"%s\" for history event \"%s\" tag \"%s\"", s->fColumnNames[j].c_str(), s->fColumnTypes[j].c_str(), s->fTableName.c_str(), s->fEventName.c_str(), tagname.c_str());
5018 }
5019 }
5020 }
5021 }
5022 }
5023
5024 // create column
5025 if (!found_column && write_enable) {
5026 std::string col_name = maybe_colname;
5027 const char* col_type = s->fSql->ColumnType(tagtype);
5028
5029 bool dupe = false;
5030 for (unsigned kk=0; kk<s->fColumnNames.size(); kk++)
5031 if (s->fColumnNames[kk] == col_name) {
5032 dupe = true;
5033 break;
5034 }
5035
5036 time_t now = time(NULL);
5037
5038 bool retry = false;
5039 for (int t=0; t<20; t++) {
5040
5041 // if duplicate column name, change it, try again
5042 if (dupe || retry) {
5044 col_name += "_";
5046 if (t > 0) {
5047 char s[256];
5048 sprintf(s, "_%d", t);
5049 col_name += s;
5050 }
5051 }
5052
5053 if (fDebug)
5054 printf("SqlHistory::update_schema: table [%s], add column [%s] type [%s] for tag [%s]\n", s->fTableName.c_str(), col_name.c_str(), col_type, tagname.c_str());
5055
5057
5058 if (status == DB_KEY_EXIST) {
5059 if (fDebug)
5060 printf("SqlHistory::update_schema: table [%s], add column [%s] type [%s] for tag [%s] failed: duplicate column name\n", s->fTableName.c_str(), col_name.c_str(), col_type, tagname.c_str());
5061 retry = true;
5062 continue;
5063 }
5064
5065 if (status != HS_SUCCESS)
5066 return status;
5067
5068 break;
5069 }
5070
5071 if (status != HS_SUCCESS)
5072 return status;
5073
5074 status = update_column(s->fEventName.c_str(), s->fTableName.c_str(), col_name.c_str(), col_type, tagname.c_str(), rpc_tid_name(tagtype), timestamp, true, have_transaction);
5075 if (status != HS_SUCCESS)
5076 return status;
5077 }
5078 }
5079
5080 if (count > 1) {
5081 // schema has duplicate tags
5082 schema_ok = false;
5083 cm_msg(MERROR, "SqlHistory::update_schema", "Duplicate tags or SQL columns for history event \"%s\" tag \"%s\"", s->fEventName.c_str(), tagname.c_str());
5085 }
5086 }
5087 }
5088
5089 // mark as unused all columns not listed in tags
5090
5091 for (unsigned k=0; k<s->fColumnNames.size(); k++)
5092 if (s->fVariables[k].name.length() > 0) {
5093 bool found = false;
5094
5095 for (int i=0; i<ntags; i++) {
5096 for (unsigned int j=0; j<tags[i].n_data; j++) {
5097 std::string tagname = tags[i].name;
5098
5099 if (tags[i].n_data > 1) {
5100 char s[256];
5101 sprintf(s, "[%d]", j);
5102 tagname += s;
5103 }
5104
5105 if (s->fVariables[k].name == tagname) {
5106 found = true;
5107 break;
5108 }
5109 }
5110
5111 if (found)
5112 break;
5113 }
5114
5115 if (!found) {
5116 // column not found in tags list
5117 schema_ok = false;
5118 if (fDebug)
5119 printf("Event [%s] Column [%s] tag [%s] not listed in tags list!\n", s->fEventName.c_str(), s->fColumnNames[k].c_str(), s->fVariables[k].name.c_str());
5120 if (write_enable) {
5121 cm_msg(MINFO, "SqlHistory::update_schema", "Deactivating SQL column \'%s\' type \'%s\' in table \"%s\" for history event \"%s\" not used for any tags", s->fColumnNames[k].c_str(), s->fColumnTypes[k].c_str(), s->fTableName.c_str(), s->fEventName.c_str());
5123
5124 status = update_column(s->fEventName.c_str(), s->fTableName.c_str(), s->fColumnNames[k].c_str(), s->fColumnTypes[k].c_str(), s->fVariables[k].tag_name.c_str(), s->fVariables[k].tag_type.c_str(), timestamp, false, have_transaction);
5125 if (status != HS_SUCCESS)
5126 return status;
5127 }
5128 }
5129 }
5130
5131 if (!write_enable)
5132 if (!schema_ok) {
5133 if (fDebug)
5134 printf("Return error!\n");
5135 return HS_FILE_ERROR;
5136 }
5137
5138 return HS_SUCCESS;
5139}
std::vector< int > fOffsets
std::vector< std::string > fColumnNames
std::vector< std::string > fColumnTypes
std::vector< bool > fColumnInactive
char name[NAME_LENGTH]
Definition history.h:111
virtual bool TypesCompatible(int midas_tid, const char *sql_type)=0
virtual const char * ColumnType(int midas_tid)=0
virtual 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)=0
#define DB_KEY_EXIST
Definition midas.h:641
#define MINFO
Definition midas.h:560
INT cm_msg_flush_buffer()
Definition midas.cxx:865
const char * rpc_tid_name(INT id)
Definition midas.cxx:11772
INT rpc_tid_size(INT id)
Definition midas.cxx:11765
static std::string MidasNameToSqlName(const char *s)
static int CreateSqlColumn(SqlBase *sql, const char *table_name, const char *column_name, const char *column_type, bool *have_transaction, int debug)
double count
Definition mdump.cxx:33
static int offset
Definition mgd.cxx:1500
INT j
Definition odbhist.cxx:40
INT k
Definition odbhist.cxx:40
DWORD type
Definition midas.h:1234
DWORD n_data
Definition midas.h:1235
char name[NAME_LENGTH]
Definition midas.h:1233
Here is the call graph for this function:
Here is the caller graph for this function:

Member Data Documentation

◆ fSql

SqlBase* SqlHistoryBase::fSql

Definition at line 4690 of file history_schema.cxx.


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