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)
 
HsSchemamaybe_reopen (const char *event_name, time_t timestamp, HsSchema *s)
 
- Public Member Functions inherited from SchemaHistoryBase
 SchemaHistoryBase ()
 
virtual ~SchemaHistoryBase ()
 
int hs_define_event (const char *event_name, time_t timestamp, int ntags, const TAG tags[])
 see hs_define_event(), returns HS_SUCCESS or HS_FILE_ERROR
 
int hs_write_event (const char *event_name, time_t timestamp, int buffer_size, const char *buffer)
 see hs_write_event(), returns HS_SUCCESS or HS_FILE_ERROR
 
int hs_flush_buffers ()
 flush buffered data to storage where it is visible to mhttpd
 
int hs_clear_cache ()
 clear internal cache, returns HS_SUCCESS
 
int hs_get_events (time_t t, std::vector< std::string > *pevents)
 get list of events that exist(ed) at given time and later (value 0 means "return all events from beginning of time"), returns HS_SUCCESS
 
int hs_get_tags (const char *event_name, time_t t, std::vector< TAG > *ptags)
 get list of history variables for given event (use event names returned by hs_get_events()) that exist(ed) at given time and later (value 0 means "all variables for this event that ever existed"), also see hs_get_tags(), returns HS_SUCCESS
 
int hs_get_last_written (time_t timestamp, int num_var, const char *const event_name[], const char *const var_name[], const int var_index[], time_t last_written[])
 
int hs_read_buffer (time_t start_time, time_t end_time, int num_var, const char *const event_name[], const char *const var_name[], const int var_index[], MidasHistoryBufferInterface *buffer[], int hs_status[])
 returns HS_SUCCESS
 
int hs_read (time_t start_time, time_t end_time, time_t interval, int num_var, const char *const event_name[], const char *const var_name[], const int var_index[], int num_entries[], time_t *time_buffer[], double *data_buffer[], int st[])
 see hs_read(), returns HS_SUCCESS
 
int hs_read_binned (time_t start_time, time_t end_time, int num_bins, int num_var, const char *const event_name[], const char *const var_name[], const int var_index[], int num_entries[], int *count_bins[], double *mean_bins[], double *rms_bins[], double *min_bins[], double *max_bins[], time_t *bins_first_time[], double *bins_first_value[], time_t *bins_last_time[], double *bins_last_value[], time_t last_time[], double last_value[], int st[])
 returns HS_SUCCESS
 
- Public Member Functions inherited from MidasHistoryInterface
 MidasHistoryInterface ()
 history type: MIDAS, ODBC, SQLITE, etc
 
virtual ~MidasHistoryInterface ()
 

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 = 0
 
std::string fConnectString
 
HsSchemaVector fWriterSchema
 
std::vector< HsSchema * > fWriterEvents
 
HsSchemaVector fReaderSchema
 

Detailed Description

Definition at line 4776 of file history_schema.cxx.

Constructor & Destructor Documentation

◆ SqlHistoryBase()

SqlHistoryBase::SqlHistoryBase ( )
inline

Definition at line 4781 of file history_schema.cxx.

4782 {
4783 fSql = NULL;
4785 }
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 4787 of file history_schema.cxx.

4788 {
4789 hs_disconnect();
4790 if (fSql)
4791 delete fSql;
4792 fSql = NULL;
4793 }
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 4819 of file history_schema.cxx.

4820{
4821 if (fDebug)
4822 printf("hs_connect [%s]!\n", connect_string);
4823
4824 assert(fSql);
4825
4826 if (fSql->IsConnected())
4827 if (strcmp(fConnectString.c_str(), connect_string) == 0)
4828 return HS_SUCCESS;
4829
4830 hs_disconnect();
4831
4832 if (!connect_string || strlen(connect_string) < 1) {
4833 // FIXME: should use "logger dir" or some such default, that code should be in hs_get_history(), not here
4834 connect_string = ".";
4835 }
4836
4838
4839 if (fDebug)
4840 printf("hs_connect: connecting to SQL database \'%s\'\n", fConnectString.c_str());
4841
4842 int status = fSql->Connect(fConnectString.c_str());
4843 if (status != DB_SUCCESS)
4844 return status;
4845
4846 return HS_SUCCESS;
4847}
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 4849 of file history_schema.cxx.

4850{
4851 if (fDebug)
4852 printf("hs_disconnect!\n");
4853
4855
4856 fSql->Disconnect();
4857
4859
4860 return HS_SUCCESS;
4861}
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 4795 of file history_schema.cxx.

4796 {
4797 if (fSql)
4798 fSql->fDebug = debug;
4800 }
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:

◆ maybe_reopen()

HsSchema * SqlHistoryBase::maybe_reopen ( const char event_name,
time_t  timestamp,
HsSchema s 
)
inlinevirtual

Implements SchemaHistoryBase.

Definition at line 4806 of file history_schema.cxx.

4806{ return s; };

◆ new_event()

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

Implements SchemaHistoryBase.

Definition at line 4863 of file history_schema.cxx.

4864{
4865 if (fDebug)
4866 printf("SqlHistory::new_event: event [%s], timestamp %s, ntags %d\n", event_name, TimeToString(timestamp).c_str(), ntags);
4867
4868 int status;
4869
4870 if (fWriterSchema.size() == 0) {
4872 if (status != HS_SUCCESS)
4873 return NULL;
4874 }
4875
4876 HsSqlSchema* s = (HsSqlSchema*)fWriterSchema.find_event(event_name, timestamp);
4877
4878 // schema does not exist, the SQL tables probably do not exist yet
4879
4880 if (!s) {
4881 status = create_table(&fWriterSchema, event_name, timestamp);
4882 if (status != HS_SUCCESS)
4883 return NULL;
4884
4885 s = (HsSqlSchema*)fWriterSchema.find_event(event_name, timestamp);
4886
4887 if (!s) {
4888 cm_msg(MERROR, "SqlHistory::new_event", "Error: Cannot create schema for event \'%s\', see previous messages", event_name);
4889 fWriterSchema.find_event(event_name, timestamp, 1);
4890 return NULL;
4891 }
4892 }
4893
4894 assert(s != NULL);
4895
4896 status = read_column_names(&fWriterSchema, s->fTableName.c_str(), s->fEventName.c_str());
4897 if (status != HS_SUCCESS)
4898 return NULL;
4899
4900 s = (HsSqlSchema*)fWriterSchema.find_event(event_name, timestamp);
4901
4902 if (!s) {
4903 cm_msg(MERROR, "SqlHistory::new_event", "Error: Cannot update schema database for event \'%s\', see previous messages", event_name);
4904 return NULL;
4905 }
4906
4907 if (0||fDebug) {
4908 printf("SqlHistory::new_event: schema for [%s] is %p\n", event_name, s);
4909 if (s)
4910 s->print();
4911 }
4912
4913 status = update_schema(s, timestamp, ntags, tags, true);
4914 if (status != HS_SUCCESS) {
4915 cm_msg(MERROR, "SqlHistory::new_event", "Error: Cannot create schema for event \'%s\', see previous messages", event_name);
4916 return NULL;
4917 }
4918
4919 status = read_column_names(&fWriterSchema, s->fTableName.c_str(), s->fEventName.c_str());
4920 if (status != HS_SUCCESS)
4921 return NULL;
4922
4923 s = (HsSqlSchema*)fWriterSchema.find_event(event_name, timestamp);
4924
4925 if (!s) {
4926 cm_msg(MERROR, "SqlHistory::new_event", "Error: Cannot update schema database for event \'%s\', see previous messages", event_name);
4927 return NULL;
4928 }
4929
4930 if (0||fDebug) {
4931 printf("SqlHistory::new_event: schema for [%s] is %p\n", event_name, s);
4932 if (s)
4933 s->print();
4934 }
4935
4936 // last call to UpdateMysqlSchema with "false" will check that new schema matches the new tags
4937
4938 status = update_schema(s, timestamp, ntags, tags, false);
4939 if (status != HS_SUCCESS) {
4940 cm_msg(MERROR, "SqlHistory::new_event", "Error: Cannot create schema for event \'%s\', see previous messages", event_name);
4941 //fDebug = 1;
4942 //update_schema(s, timestamp, ntags, tags, false);
4943 //abort();
4944 return NULL;
4945 }
4946
4947 HsSqlSchema* e = new HsSqlSchema();
4948
4949 *e = *s; // make a copy of the schema
4950
4951 return e;
4952}
std::string fEventName
size_t 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 fWriterSchema
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 4954 of file history_schema.cxx.

4955{
4956 if (fDebug)
4957 printf("SqlHistory::read_schema: loading schema for event [%s] at time %s\n", event_name, TimeToString(timestamp).c_str());
4958
4959 int status;
4960
4961 if (sv->size() == 0) {
4963 if (status != HS_SUCCESS)
4964 return status;
4965 }
4966
4967 //sv->print(false);
4968
4969 if (event_name == NULL)
4970 return HS_SUCCESS;
4971
4972 for (size_t i=0; i<sv->size(); i++) {
4973 HsSqlSchema* h = (HsSqlSchema*)(*sv)[i];
4974 // skip schema with already read column names
4975 if (h->fVariables.size() > 0)
4976 continue;
4977 // skip schema with different name
4978 if (!MatchEventName(h->fEventName.c_str(), event_name))
4979 continue;
4980
4981 size_t nn = sv->size();
4982
4983 status = read_column_names(sv, h->fTableName.c_str(), h->fEventName.c_str());
4984
4985 // if new schema was added, loop all over again
4986 if (sv->size() != nn)
4987 i=0;
4988 }
4989
4990 //sv->print(false);
4991
4992 return HS_SUCCESS;
4993}
std::vector< HsSchemaEntry > fVariables
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 4995 of file history_schema.cxx.

4996{
4997 int status;
4998 bool have_transaction = false;
4999
5000 status = update_schema1(s, timestamp, ntags, tags, write_enable, &have_transaction);
5001
5002 if (have_transaction) {
5003 int xstatus;
5004
5005 if (status == HS_SUCCESS)
5007 else
5009
5010 if (xstatus != DB_SUCCESS) {
5011 return HS_FILE_ERROR;
5012 }
5013 have_transaction = false;
5014 }
5015
5016 return status;
5017}
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 5019 of file history_schema.cxx.

5020{
5021 int status;
5022
5023 if (fDebug)
5024 printf("update_schema1\n");
5025
5026 // check that compare schema with tags[]
5027
5028 bool schema_ok = true;
5029
5030 int offset = 0;
5031 for (int i=0; i<ntags; i++) {
5032 for (unsigned int j=0; j<tags[i].n_data; j++) {
5033 int tagtype = tags[i].type;
5034 std::string tagname = tags[i].name;
5035 std::string maybe_colname = MidasNameToSqlName(tags[i].name);
5036
5037 if (tags[i].n_data > 1) {
5038 char s[256];
5039 sprintf(s, "[%d]", j);
5040 tagname += s;
5041
5042 sprintf(s, "_%d", j);
5043 maybe_colname += s;
5044 }
5045
5046 int count = 0;
5047
5048 for (size_t j=0; j<s->fVariables.size(); j++) {
5049 // NB: inactive columns will be reactivated or recreated by the if(count==0) branch. K.O.
5050 if (s->fColumnInactive[j])
5051 continue;
5052 if (tagname == s->fVariables[j].name) {
5053 if (s->fSql->TypesCompatible(tagtype, s->fColumnTypes[j].c_str())) {
5054 if (count == 0) {
5055 s->fOffsets[j] = offset;
5057 }
5058 count++;
5059 if (count > 1) {
5060 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());
5062 }
5063 } else {
5064 // column with incompatible type, mark it as unused
5065 schema_ok = false;
5066 if (fDebug)
5067 printf("Incompatible column!\n");
5068 if (write_enable) {
5069 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());
5071
5072 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);
5073 if (status != HS_SUCCESS)
5074 return status;
5075 }
5076 }
5077 }
5078 }
5079
5080 if (count == 0) {
5081 // tag does not have a corresponding column
5082 schema_ok = false;
5083 if (fDebug)
5084 printf("No column for tag %s!\n", tagname.c_str());
5085
5086 bool found_column = false;
5087
5088 if (write_enable) {
5089 for (size_t j=0; j<s->fVariables.size(); j++) {
5090 if (tagname == s->fVariables[j].tag_name) {
5091 bool typeok = s->fSql->TypesCompatible(tagtype, s->fColumnTypes[j].c_str());
5092 if (typeok) {
5093 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());
5095
5096 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);
5097 if (status != HS_SUCCESS)
5098 return status;
5099
5100 if (count == 0) {
5101 s->fOffsets[j] = offset;
5103 }
5104 count++;
5105 found_column = true;
5106 if (count > 1) {
5107 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());
5109 }
5110 }
5111 }
5112 }
5113 }
5114
5115 // create column
5116 if (!found_column && write_enable) {
5117 std::string col_name = maybe_colname;
5118 const char* col_type = s->fSql->ColumnType(tagtype);
5119
5120 bool dupe = false;
5121 for (size_t kk=0; kk<s->fColumnNames.size(); kk++)
5122 if (s->fColumnNames[kk] == col_name) {
5123 dupe = true;
5124 break;
5125 }
5126
5127 time_t now = time(NULL);
5128
5129 bool retry = false;
5130 for (int t=0; t<20; t++) {
5131
5132 // if duplicate column name, change it, try again
5133 if (dupe || retry) {
5135 col_name += "_";
5137 if (t > 0) {
5138 char s[256];
5139 sprintf(s, "_%d", t);
5140 col_name += s;
5141 }
5142 }
5143
5144 if (fDebug)
5145 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());
5146
5148
5149 if (status == DB_KEY_EXIST) {
5150 if (fDebug)
5151 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());
5152 retry = true;
5153 continue;
5154 }
5155
5156 if (status != HS_SUCCESS)
5157 return status;
5158
5159 break;
5160 }
5161
5162 if (status != HS_SUCCESS)
5163 return status;
5164
5165 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);
5166 if (status != HS_SUCCESS)
5167 return status;
5168 }
5169 }
5170
5171 if (count > 1) {
5172 // schema has duplicate tags
5173 schema_ok = false;
5174 cm_msg(MERROR, "SqlHistory::update_schema", "Duplicate tags or SQL columns for history event \"%s\" tag \"%s\"", s->fEventName.c_str(), tagname.c_str());
5176 }
5177 }
5178 }
5179
5180 // mark as unused all columns not listed in tags
5181
5182 for (size_t k=0; k<s->fColumnNames.size(); k++)
5183 if (s->fVariables[k].name.length() > 0) {
5184 bool found = false;
5185
5186 for (int i=0; i<ntags; i++) {
5187 for (unsigned int j=0; j<tags[i].n_data; j++) {
5188 std::string tagname = tags[i].name;
5189
5190 if (tags[i].n_data > 1) {
5191 char s[256];
5192 sprintf(s, "[%d]", j);
5193 tagname += s;
5194 }
5195
5196 if (s->fVariables[k].name == tagname) {
5197 found = true;
5198 break;
5199 }
5200 }
5201
5202 if (found)
5203 break;
5204 }
5205
5206 if (!found) {
5207 // column not found in tags list
5208 schema_ok = false;
5209 if (fDebug)
5210 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());
5211 if (write_enable) {
5212 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());
5214
5215 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);
5216 if (status != HS_SUCCESS)
5217 return status;
5218 }
5219 }
5220 }
5221
5222 if (!write_enable)
5223 if (!schema_ok) {
5224 if (fDebug)
5225 printf("Return error!\n");
5226 return HS_FILE_ERROR;
5227 }
5228
5229 return HS_SUCCESS;
5230}
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 4779 of file history_schema.cxx.


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