autobuild-tools/code/sys_nicmonitor/include/db_api/odb_tablenet.h

/*******************************************************************************
ModuleName:   ODB Real Time Database management system
FileName:	  odb_tablenet.h
DESCRIPTION:  for class CTableNet of net access
FUNCTION LIST:
COMMENT:      for net access
History:                                                        
Date          Version     Modifier                Activities
2004-06-25    1.1         						add context_no parameter
2003-01-09    1.0                              modify
2003-12-20    1.0                              modify
================================================================================
2003-01-09    1.0                              created
*******************************************************************************/
#ifndef __ODB_TABLENET_h__
#define __ODB_TABLENET_h__

#ifndef	__ODB_COMMON_H__
#include "odb_common.h"
#endif

#ifndef __PROFILE_FILE_H__
#include "db_api/odb_profile.h"
#endif

#ifndef	__ODB_TABLEBASE_H__
#include "db_api/odb_tablebase.h"
#endif

#ifndef __ODB_NETFACTORY_h__
#include "db_api/odb_netfactory.h"
#endif

#ifndef	__ODB_TABLE_H__
#include "db_api/odb_table.h"
#endif

#include "task_service.h"
#include "odb_net_m.h"
#include "codb_net.h"
#include <stdio.h>

#ifdef _WINDOWS64
#ifdef ODB_API_LIB_EXPORTS
#define ODB_API_LIB_API __declspec(dllexport)
#else
#define ODB_API_LIB_API __declspec(dllimport)
#endif
#else
#define ODB_API_LIB_API
#endif

using namespace std;
//using namespace RTDB_SERVER;
using namespace ODB;

//============================================================================//

namespace NET_ODB
{
	typedef struct   
	{
		std::string scn_name;
		std::string subscn_name;
		int type;
	} TTableNetPriv;
	

class ODB_API_LIB_API CTableNet: public CTableBase
{
public:
	CTableNet();
	CTableNet(const int app_no, const short context_no = 0);
	CTableNet(const int app_no, const int table_no, const short context_no=0);
	CTableNet(const std::string& scenario_name, const int scenario_inst_no, const std::string& sub_scenario_name, const int sub_scenario_inst_no, const int table_no);
	CTableNet(const int scenario_no, const int scenario_inst_no, const int sub_scenario_no, const int sub_scenario_inst_no, const int table_no);

	~CTableNet();

	int 	Open(const int app_no, const int table_no, const short context_no=0);
	int 	Open(const int table_no);
	cmnInt32 Open (const std::string& scenario_name,
                        const int scenario_inst_no,
                        const std::string& sub_scenario_name,
                        const int sub_scenario_inst_no,
			int table_no); 
	cmnInt32 Open (const int scenario_no,
					const int scenario_inst_no,
                    const int sub_scenario_no,
                    const int sub_scenario_inst_no,
                    const int table_no);

	int 	SetAppNo(const int app_no, const short context_no = 0);
	int 	SetHostMode(const char* host_name);
	//int SetManagedMode(const bool is_managed);
	
        int     SetScenario (const std::string& scenario_name,
                        const int scenario_inst_no,
                        const std::string& sub_scenario_name,
                        const int sub_scenario_inst_no);
        int     SetScenario (const int scenario_no,
                        const int scenario_inst_no,
                        const int sub_scenario_no,
                        const int sub_scenario_inst_no);

public:	
	int	TableGet(CBuffer& buf_base);
	int     TableGet(CBuffer& buf_base, short area_no);
	int     TableGetWithAreaSplit(const int field_no, CBuffer& buf_base, short area_no);
	int     TableGetWithOrder(CBuffer& buf_base);
	int 	TableGetSplit(const int field_no, CBuffer& buf_base);
#ifdef _APP_SYS_SUBSTATION
	int	TableGetAll(CBuffer& buf_base); //Get all columns included virtual columns
#endif
	int	TableGet(const int field_no, CBuffer& buf_base);
	int TableGet(CBuffer& buf_base, const int upper, const int lower);//add select * from XXXX limit (lower, upper);
	int	TableGetSplit(const char* field_name, CBuffer& buf_base);
	int	TableGetSplit(CBuffer& buf_base, const int upper, const int lower);
	int	TableGet(const char* field_name, CBuffer& buf_base);
	int	TableGet(const char* field_name, CBuffer& buf_base, const int upper, const int lower, std::vector<MEMBER_DEFINITION>& vec_mem);
	int	TableGetSplit (const std::vector<int>& vec_field_no, CBuffer& buf_base);
	int	TableGetSplit(const char* field_name, CBuffer& buf_base, const int upper, const int lower, const std::vector<MEMBER_DEFINITION>& vec_mem);
	int	TableGet(const std::vector<int>& vec_field_no, CBuffer& buf_base);
	int FormKEYCondition(const char* column_name_eng, const RTDB_KEY_STRU& key_value, const char* op, std::string& cond_str);	
	int SqlGetSplit(const char* str_sql, CBuffer& buf_base);
	int	SqlGetSplit(const char* keyid_sql, const std::vector<int>& vec_field_no, const int upper, const int lower, CBuffer& buf_base, const std::vector<MEMBER_DEFINITION>& vec_mem);
	int SqlGet(const char* str_sql, CBuffer& buf_base);
	int SqlGet(const char* str_sql, CBuffer& buf_base, std::vector<MEMBER_DEFINITION>& vec_mem);
	int SqlGet(const char* str_sql, CBuffer& buf_base, short area_no);
	int SqlGetWithAreaSplit(const char* str_sql, CBuffer& buf_base, short area_no);
	int SqlGetSplitWithOrder(const char* str_sql, CBuffer& buf_base);
//////
	int	TableGet(char** buf_ptr, int& buf_size);	  
	int	TableGetSplit (const int field_no, char** field_buf_ptr, int& buf_size);                           //all record
	int	TableGet(const int field_no, char** field_buf_ptr, int& buf_size);   //one field of all record
	int	TableGetSplit (const std::vector<int>& vec_field_no, char** field_buf_ptr, int& buf_size);
	int	TableGet(const std::vector<int>& vec_field_no, char** field_buf_ptr, int& buf_size); //get many fields of all record
	int	TableGetSplit (const char* field_name, char** field_buf_ptr, int& buf_size);
	int	TableGet(const char* field_name, char** field_buf_ptr, int& buf_size); //Added at 2003-11-22
	
	int	TableGetByKeySplit (const char* key_ptr, const int field_no, char* field_buf_ptr, const int buf_size);
	int	TableGetByKey(const char* key_ptr, char* buf_ptr, const int buf_size);     //one record by key word
	int	TableGetByKey(const char* key_ptr, const int field_no, char* field_buf_ptr, const int buf_size); //one field of a record
	int	TableGetByKeySplit (const char* key_ptr, const std::vector<int>& vec_field_no, char* field_buf_ptr, const int buf_size);
	int	TableGetByKey(const char* key_ptr, const std::vector<int>& vec_field_no, char* field_buf_ptr, const int buf_size); //get many fields of a record
	int	TableGetByKeySplit (const char* key_ptr, const char* field_name, char* field_buf_ptr, const int buf_size);
	int	TableGetByKey(const char* key_ptr, const char* field_name, char* field_buf_ptr, const int buf_size);               //Added at 2003-11-22
	int	TableGetByKeySplit (const char* key_ptr, const int keybuf_size, const std::vector<int>& vec_field_no, char* field_buf_ptr, const int buf_size);
	int	TableGetByKey(const char* key_ptr, const int keybuf_size, const std::vector<int>& vec_field_no, char* field_buf_ptr, const int buf_size);

  int	TableWriteSplit (const char* buf_ptr, const int buf_size);
	int	TableWrite(const char* buf_ptr, const int buf_size);		           //write one or more record
	int	TableWriteSync(const char* buf_ptr, const int buf_size);		           //write one or more record
	int	DeleteRecordSplit (const char* key_ptr);
	int	DeleteRecord(const char* key_ptr); 
	int	DeleteRecordSync(const char* key_ptr);    
	int	DeleteRecordsSplit (const char* key_ptr, int key_num);                                 //delete a record by key word
	int	DeleteRecords(const char* key_ptr, int key_num);
		//key_ptr锟角讹拷锟斤拷丶锟斤拷锟斤拷锟缴碉拷一锟斤拷锟斤拷锟介，key_num锟斤拷示删锟斤拷锟侥革拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟缴撅拷锟斤拷锟绞憋拷锟揭伙拷锟斤拷锟揭?锟接猴拷锟斤拷前删锟斤拷锟斤拷锟斤拷一锟斤拷锟斤拷要锟叫断关硷拷锟斤拷锟角凤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟侥讹拷锟斤拷丶锟斤拷锟揭伙拷锟缴撅拷锟斤拷锟斤拷锟斤拷锟斤拷锟揭?锟街成硷拷锟斤拷锟斤拷锟斤拷删锟斤拷锟斤拷
	int	DeleteAlignedRecordsSplit (const char* key_ptr, int direction);
	int	DeleteAlignedRecords(const char* key_ptr, int direction = FORWARD);
		//direction锟斤拷示锟斤拷锟斤拷FORWARD锟斤拷示删锟斤拷锟斤拷锟斤拷key_ptr锟截硷拷锟街猴拷锟斤拷前锟斤拷锟斤拷锟斤拷屑锟铰硷拷锟狡╋拷锟斤拷锟斤拷key_ptr锟斤拷应锟斤拷9锟斤拷锟斤拷录锟斤拷锟斤拷么锟斤拷删锟斤拷锟斤拷0锟斤拷9锟侥硷拷录锟斤拷锟斤拷BACKWARD锟斤拷示删锟斤拷key_ptr锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷屑锟铰硷拷锟?
	
	//int	TableModify(const char* buf_ptr, const int buf_size); //unused 2002-11-14     //modify one or many record
	int	TableModify(const char* buf_ptr, const int record_num, const int record_size);
	int	TableModify(const int field_no, const char* field_buf_ptr, const int buf_size);  //modify one field of all record by field no
	
	int	TableModifyByKeySplit (const char* key_ptr, const int field_no, const char* field_buf_ptr, const int buf_size);
	int	TableModifyByKey(const char* key_ptr, const int field_no, const char* field_buf_ptr, const int buf_size);      //modify one field by key word and field no, only one record
	int	TableModifyByKeySplit (const char* key_ptr, const int keybuf_size, const std::vector<int>& vec_field_no, const char* field_buf_ptr, const int buf_size);
	int	TableModifyByKey(const char* key_ptr, const int keybuf_size, const int field_no, const char* field_buf_ptr, const int buf_size); //modify one field or all fields of many records by key word
	int	TableModifyByKey(const char* key_ptr, const int keybuf_size, const std::vector<int>& vec_field_no, const char* field_buf_ptr, const int buf_size); //modify many fields or all fields of many records by key word		

	//
	//
	int	TableModify(const char* field_name, const char* field_buf_ptr, const int buf_size)  ;
	int	TableModify(const std::vector<int>& vec_field_no, const char* field_buf_ptr, const int buf_size);
  
  int	TableModifyByKeySplit (const char* key_ptr, const char* field_name, const char* field_buf_ptr, const int buf_size);
	int	TableModifyByKey(const char* key_ptr, const char* field_name, const char* field_buf_ptr, const int buf_size);
	int	TableModifyByKeySplit (const char* key_ptr, const std::vector<int>& vec_field_no, const char* field_buf_ptr, const int buf_size);
	int	TableModifyByKey(const char* key_ptr, const std::vector<int>& vec_field_no, const char* field_buf_ptr, const int buf_size);
	int	TableModifyByKeySplit (const char* key_ptr, const int keybuf_size, const char* field_name, const char* field_buf_ptr, const int buf_size);
	int	TableModifyByKey(const char* key_ptr, const int keybuf_size, const char* field_name, const char* field_buf_ptr, const int buf_size);
	int     TableModifyByKeySync(const char* key_ptr, const int keybuf_size, const char* field_name, const char* field_buf_ptr, const int buf_size);
 	int     TableModifyByKeySync(const char* key_ptr, const int keybuf_size, const std::vector<int>& vec_field_no, const char* field_buf_ptr, const int buf_size); //modiify many fields or all fields of many records by key word
  
  int	TableUpdateSplit (const char* buf_ptr, const int buf_size);
	int	TableUpdate(const char* buf_ptr, const int buf_size); //update one or more record
	
	int	TableClearSplit();
	int	TableClear();       
	//
	//SQL interface 
	//
	//int SqlUpdate(const char* str_sql);
	int   SqlGetSplit (const char* str_sql, char** buf_ptr, int& buf_size);
	int 	SqlGet(const char* str_sql, char** buf_ptr, int& buf_size);
	
public:
	int 	GetFieldInfo(std::vector<struct ::FIELD_BASE_INFO>& vec_filed);
	int 	GetFieldInfo(const std::vector<int>  vec_field_no, std::vector<struct ::FIELD_BASE_INFO>& vec_field);
	
	int	GetTableParaSplit(short& field_num, int& record_num, int& record_size);
	int	GetTablePara(short& field_num, int& record_num, int& record_size);
	int	GetTablePara(struct TABLE_PARA& table_para); 
	int	GetTablePara(struct STDB_FIELD_TAB* field_descrbptr, const int buf_size);
	int	GetTablePara(struct TABLE_PARA& table_para, struct STDB_FIELD_TAB* field_descrbptr, const int buf_size);
	int	GetTablePara(struct TABLE_PARA& table_para, struct STDB_FIELD_TAB** field_descrbptr, int& buf_size);
	int	GetTablePara(struct TABLE_PARA& table_para, std::vector<struct STDB_FIELD_TAB>& vec_field_para);
	int	GetTablePara(const char* str_attribute, char** field_para_ptr, int& buf_size);
#ifdef _APP_SYS_SUBSTATION
	int	GetTableParaAll(struct TABLE_PARA& table_para, std::vector<struct STDB_FIELD_TAB>& vec_field_para);
	//jinjing 20120815
	int	GetTableParaVir(std::vector<struct STDB_VIR_FIELD_TAB>& vec_virfield_para); 
#endif
	//lmj add 2004.1126
	int	GetTablePara(struct TABLE_PARA& table_para, CBuffer& buf_base);
	int	GetTablePara(struct STDB_FIELD_TAB** field_descrbptr, int& buf_size);
	
	int 	GetFieldPara(struct FIELD_BASE_INFO& field_info);
	
	int 	GetFieldPara(vector<struct FIELD_BASE_INFO>& field_info_vec);
	
	int 	GetFieldNameByNo(char* field_name, const int field_no, const bool is_eng=true);
	int	GetFieldNoByName(int& field_no, const char* field_name, const bool is_eng=true);

	int 	GetTableNameByNo(char* table_name, const int table_no, const bool is_eng=true);
	int 	GetTableNoByName(int& table_no, const char* table_name, const bool is_eng=true);
	
	int 	GetAppNameByNo(char* app_name, const int app_no);
	int 	GetAppNoByName(int& app_no, const char* app_name);
	
	int 	GetTableNoByName(const char* table_name, const bool is_eng=true);
	int 	GetTableNoByName(std::vector<int>& vec_table_no , const std::vector<string>& vec_table_name, const bool is_eng=true);
	int 	GetTableNameByNo(std::string& table_name, const int table_no, const bool is_eng=true);

	int	GetAllOdbNoByAppName(int& app_no, std::vector<NAME_ID>& vec_table, const char* app_name, const bool is_eng=true);
	int	GetAllOdbNoByAppNo(char* app_name, std::vector<NAME_ID>& vec_table, const int app_no, const bool is_eng=true);

        int     GetAllOdbNoBySubScenarioName (int& sub_scenario_id, std::vector<NAME_ID>& vec_table,
	                          const std::string& sub_scenario,  const unsigned int sub_scenario_inst,
                                  const std::string& scenario, const unsigned int scenario_inst, const bool is_eng=true);
        int     GetAllOdbNoBySubScenarioNo (std::string& sub_scenario, std::vector<NAME_ID>& vec_table,
	                        const int sub_scenario_id, const unsigned int sub_scenario_inst, 
                                const int scenario_id, const unsigned int scenario_inst, const bool is_eng=true);
	
	int ConGetSplit(const int con_field_no, const char* con_field_value, const int con_value_size, CBuffer& buf_base);
	int ConGet(const int con_field_no, const char* con_field_value, const int con_value_size, CBuffer& buf_base);
	int ConGetSplit(const int get_field_no, const int con_field_no, const char* con_field_value, const int con_value_size, CBuffer& buf_base);
	int ConGet(const int get_field_no, const int con_field_no, const char* con_field_value, const int con_value_size, CBuffer& buf_base);
	int ConGetSplit(const vector<int>& con_field_no_array, const vector<int>& get_field_no_array, char* con_field_value, const int con_value_size, CBuffer& buf_base);
	int ConGet(const vector<int>& con_field_no_array, const vector<int>& get_field_no_array, char* con_field_value, const int con_value_size, CBuffer& buf_base);

public:
	int	PingRtdbServer(int req_data , int & rep_data);
	int GetKeySize(const int table_no); //wj added for d5000 C-API
	
public:
	int SetDomainName(const char* domain_name);
	int SetSecLabel(tSecLabel& sec_label);
	void ClearDomainName();
	int SetSliceNo(cmnUint32 slice_no);

private:
	int	TableModify(const char* buf_ptr, const int buf_size);

private:
// public:
	int 	Start();
	int 	Refresh();
	int 	Refresh(int app_no);
	int 	GetSliceByKey(const char* key, cmnUint32& slice_no);
	int 	GetAllSlice(vector<int>& slice_no);

	int	ParseRsp(char** buf_ptr, int& buf_size, const RTDB_PROTO::RSP_READ& read_rsp);
	int	ParseRsp(char* buf_ptr, const int buf_size, const RTDB_PROTO::RSP_READ& read_rsp);
	int 	GetKeyInfo();
	int     GetKeyInfoSlice();
	inline int slice_app_to_no(int slice_app_no){return slice_app_no % 1000;}
	inline int slice_no_to_app(int slice_no){return slice_no+AP_SCADA_AREA;}
	
	bool 	IsApplication(const int app_no);
	
private:
	CTableNet(const CTableNet&);
	CTableNet& operator=(const CTableNet&);

private:
	RTDB_SERVER::CODB_NET*      m_OdbNet;
	CNetFactory*      m_Factory;
	//Handle   m_Handle; //for service_bus
	
	NProfile::CProfile  *m_IniFile;
	//
	short             m_ContextNo;
	int               m_AppNo;
	int               m_TableNo;
	
//	std::string		  m_scenario_name;
	int				  m_scenario_no;
//	std::string		  m_sub_scenario_name;
	int				  m_sub_scenario_no;
	int 			  m_scenario_inst_no;
	int 			  m_sub_scenario_inst_no;

	DB_BYTE_T         m_ByteTag;
	
	bool              m_IsSysAdmHost;	
	char              m_HostName[MAX_NAME_STRING_LEN];
	
	char m_DomainName[40];
	tSecLabel m_SecLabel;
	bool m_IsRemote;
	int m_SliceNo;
	TaskService* task_service;

	std::vector<int>  m_VecKey;
	std::vector<int>  m_IsSliced;
	std::vector<struct FIELD_BASE_INFO> m_VecField;
	
	TTableNetPriv	  *m_pPrvStru;
};

}

#endif