eis/src/dbax/T_PDO_LIST.cpp

// Version:		2021.11.3  14:35:18

// File: T_PDO_LIST.cpp

#include "T_PDO_LIST.h"

T_PDO_LIST::T_PDO_LIST(){
//  initialise all membervariables
	initial();
}
T_PDO_LIST::~T_PDO_LIST(){
}
void T_PDO_LIST::initial(){
//  initialise all membervariables
	set_extId((char*)"");
	set_entId((char*)"");
	set_entIdZi(-1);
	set_steelgrade((char*)"");
	set_steelgradeZi(-1);
	set_start(0);
	set_startZi(-1);
	set_end(0);
	set_endZi(-1);
	set_starttime((char*)"");
	set_starttimeZi(-1);
	set_endtime((char*)"");
	set_endtimeZi(-1);
	set_decision((char*)"");
	set_decisionZi(-1);
	set_SpeedRate(0);
	set_SpeedRateZi(-1);
	set_Yield(0);
	set_YieldZi(-1);
	set_AutoRate(0);
	set_AutoRateZi(-1);
	set_Energy(0);
	set_EnergyZi(-1);
	set_Quality(0);
	set_QualityZi(-1);
	set_AlarmScore(0);
	set_AlarmScoreZi(-1);
	set_OverallScore((char*)"");
	set_OverallScoreZi(-1);
	set_Elong((char*)"");
	set_ElongZi(-1);
	set_TC((char*)"");
	set_TCZi(-1);
// initialies Primary key members
	set_k_extId((char*)"");
}
T_PDO_LIST::T_PDO_LIST(const char* arg1)
{
	initial();
	setPrimKey (arg1);
	//read DB record
	dbAccess = true;
	dbMessage = readDB();
	if ( dbMessage != NULL ) {dbAccess = false;}
}

char* T_PDO_LIST:: execute(const char* sql , long* count){
	return( db.execute( sql , count ) );
}

char* T_PDO_LIST:: dbCommit(){
	return( db.dbCommit( ) );
}

char* T_PDO_LIST:: dbRollback(){
	return( db.dbRollback( ) );
}

char* T_PDO_LIST::readDB(){
	// DB Trace is off
	return( db.readDB(*this) );
}

char* T_PDO_LIST::updateDB(){
	// DB Trace is off
	return( db.updateDB(*this) );
}

char* T_PDO_LIST::insertDB(){
	// DB Trace is off
	return( db.insertDB(*this) );
}

char* T_PDO_LIST::deleteDB(){
	// DB Trace is off
	return( db.deleteDB(*this) );
}

char* T_PDO_LIST::deleteDB(const char * where, long* count){
	// DB Trace is off
	return( db.deleteDB( where , count ) );
}

char* T_PDO_LIST::openSetDB(const char * where,const char* order){
	// DB Trace is off
	return( db.openSetDB( where , order ) );
}

char* T_PDO_LIST::countDB(const char * where, long* count){
	// DB Trace is off
	return( db.countDB( where , count ) );
}

char* T_PDO_LIST::getSetDB(){
	// DB Trace is off
	return( db.getSetDB(*this) );
}

char* T_PDO_LIST::closeSetDB(){
	// DB Trace is off
	return( db.closeSetDB() );
}

char* T_PDO_LIST::storeDB(){
	char* ret = NULL;
	setKeysFromRecord();
	ret=db.updateDB(*this);
	if(ret != NULL){
		ret=db.insertDB(*this);
		if(ret != NULL){
			dbAccess = false;
			return(ret);
		}
	}
	return(ret);
}

//	 public methode setPrimKey T_PDO_LIST
//
//	this methode stores the unique key attributes
//
void T_PDO_LIST::setPrimKey( const char* arg1 ){
	strncpy( (char*)c_k_extId , arg1 , sizeof(c_k_extId) );
	c_k_extId[sizeof(c_k_extId)-1] = '\0';
} // end of methode

void T_PDO_LIST::initInsertKeys( const char* arg1 ){
	setPrimKey (  arg1);
	strncpy( (char*)c_extId , arg1 , sizeof(c_extId) );
	c_extId[sizeof(c_extId)-1] = '\0';
} // end of methode
void T_PDO_LIST::setKeysFromRecord(){
	set_k_extId( extId() );
} // end of methode
//
//O P E R A T O R  + 
//===================
//
T_PDO_LIST T_PDO_LIST::operator+(const T_PDO_LIST &inst) const{
	T_PDO_LIST ptrT_PDO_LIST(*this);
//----------------------------------------------------------
	ptrT_PDO_LIST.set_extId(inst.extId());
//----------------------------------------------------------
	if(inst.entIdZi() != -1){
		ptrT_PDO_LIST.set_entId(inst.entId());
		ptrT_PDO_LIST.set_entIdZi(inst.entIdZi());
	}
//----------------------------------------------------------
	if(inst.steelgradeZi() != -1){
		ptrT_PDO_LIST.set_steelgrade(inst.steelgrade());
		ptrT_PDO_LIST.set_steelgradeZi(inst.steelgradeZi());
	}
//----------------------------------------------------------
	if(inst.startZi() != -1){
		ptrT_PDO_LIST.set_start(inst.start());
		ptrT_PDO_LIST.set_startZi(inst.startZi());
	}
//----------------------------------------------------------
	if(inst.endZi() != -1){
		ptrT_PDO_LIST.set_end(inst.end());
		ptrT_PDO_LIST.set_endZi(inst.endZi());
	}
//----------------------------------------------------------
	if(inst.starttimeZi() != -1){
		ptrT_PDO_LIST.set_starttime(inst.starttime());
		ptrT_PDO_LIST.set_starttimeZi(inst.starttimeZi());
	}
//----------------------------------------------------------
	if(inst.endtimeZi() != -1){
		ptrT_PDO_LIST.set_endtime(inst.endtime());
		ptrT_PDO_LIST.set_endtimeZi(inst.endtimeZi());
	}
//----------------------------------------------------------
	if(inst.decisionZi() != -1){
		ptrT_PDO_LIST.set_decision(inst.decision());
		ptrT_PDO_LIST.set_decisionZi(inst.decisionZi());
	}
//----------------------------------------------------------
	if(inst.SpeedRateZi() != -1){
		ptrT_PDO_LIST.set_SpeedRate(inst.SpeedRate());
		ptrT_PDO_LIST.set_SpeedRateZi(inst.SpeedRateZi());
	}
//----------------------------------------------------------
	if(inst.YieldZi() != -1){
		ptrT_PDO_LIST.set_Yield(inst.Yield());
		ptrT_PDO_LIST.set_YieldZi(inst.YieldZi());
	}
//----------------------------------------------------------
	if(inst.AutoRateZi() != -1){
		ptrT_PDO_LIST.set_AutoRate(inst.AutoRate());
		ptrT_PDO_LIST.set_AutoRateZi(inst.AutoRateZi());
	}
//----------------------------------------------------------
	if(inst.EnergyZi() != -1){
		ptrT_PDO_LIST.set_Energy(inst.Energy());
		ptrT_PDO_LIST.set_EnergyZi(inst.EnergyZi());
	}
//----------------------------------------------------------
	if(inst.QualityZi() != -1){
		ptrT_PDO_LIST.set_Quality(inst.Quality());
		ptrT_PDO_LIST.set_QualityZi(inst.QualityZi());
	}
//----------------------------------------------------------
	if(inst.AlarmScoreZi() != -1){
		ptrT_PDO_LIST.set_AlarmScore(inst.AlarmScore());
		ptrT_PDO_LIST.set_AlarmScoreZi(inst.AlarmScoreZi());
	}
//----------------------------------------------------------
	if(inst.OverallScoreZi() != -1){
		ptrT_PDO_LIST.set_OverallScore(inst.OverallScore());
		ptrT_PDO_LIST.set_OverallScoreZi(inst.OverallScoreZi());
	}
//----------------------------------------------------------
	if(inst.ElongZi() != -1){
		ptrT_PDO_LIST.set_Elong(inst.Elong());
		ptrT_PDO_LIST.set_ElongZi(inst.ElongZi());
	}
//----------------------------------------------------------
	if(inst.TCZi() != -1){
		ptrT_PDO_LIST.set_TC(inst.TC());
		ptrT_PDO_LIST.set_TCZi(inst.TCZi());
	}
	return (ptrT_PDO_LIST);
}

//
//O P E R A T O R  = 
//===================
//
const T_PDO_LIST& T_PDO_LIST::operator=(const T_PDO_LIST &inst){
//----------------------------------------------------------
	this->set_extId(inst.extId());
//----------------------------------------------------------
	this->set_entId(inst.entId());
	this->set_entIdZi(inst.entIdZi());
//----------------------------------------------------------
	this->set_steelgrade(inst.steelgrade());
	this->set_steelgradeZi(inst.steelgradeZi());
//----------------------------------------------------------
	this->set_start(inst.start());
	this->set_startZi(inst.startZi());
//----------------------------------------------------------
	this->set_end(inst.end());
	this->set_endZi(inst.endZi());
//----------------------------------------------------------
	this->set_starttime(inst.starttime());
	this->set_starttimeZi(inst.starttimeZi());
//----------------------------------------------------------
	this->set_endtime(inst.endtime());
	this->set_endtimeZi(inst.endtimeZi());
//----------------------------------------------------------
	this->set_decision(inst.decision());
	this->set_decisionZi(inst.decisionZi());
//----------------------------------------------------------
	this->set_SpeedRate(inst.SpeedRate());
	this->set_SpeedRateZi(inst.SpeedRateZi());
//----------------------------------------------------------
	this->set_Yield(inst.Yield());
	this->set_YieldZi(inst.YieldZi());
//----------------------------------------------------------
	this->set_AutoRate(inst.AutoRate());
	this->set_AutoRateZi(inst.AutoRateZi());
//----------------------------------------------------------
	this->set_Energy(inst.Energy());
	this->set_EnergyZi(inst.EnergyZi());
//----------------------------------------------------------
	this->set_Quality(inst.Quality());
	this->set_QualityZi(inst.QualityZi());
//----------------------------------------------------------
	this->set_AlarmScore(inst.AlarmScore());
	this->set_AlarmScoreZi(inst.AlarmScoreZi());
//----------------------------------------------------------
	this->set_OverallScore(inst.OverallScore());
	this->set_OverallScoreZi(inst.OverallScoreZi());
//----------------------------------------------------------
	this->set_Elong(inst.Elong());
	this->set_ElongZi(inst.ElongZi());
//----------------------------------------------------------
	this->set_TC(inst.TC());
	this->set_TCZi(inst.TCZi());
	return (*this);
}
//
//C O P Y - C O N S T R U C T O R
//===================
//
T_PDO_LIST::T_PDO_LIST(const T_PDO_LIST &inst){
//----------------------------------------------------------
	this->set_extId(inst.extId());
//----------------------------------------------------------
	this->set_entId(inst.entId());
	this->set_entIdZi(inst.entIdZi());
//----------------------------------------------------------
	this->set_steelgrade(inst.steelgrade());
	this->set_steelgradeZi(inst.steelgradeZi());
//----------------------------------------------------------
	this->set_start(inst.start());
	this->set_startZi(inst.startZi());
//----------------------------------------------------------
	this->set_end(inst.end());
	this->set_endZi(inst.endZi());
//----------------------------------------------------------
	this->set_starttime(inst.starttime());
	this->set_starttimeZi(inst.starttimeZi());
//----------------------------------------------------------
	this->set_endtime(inst.endtime());
	this->set_endtimeZi(inst.endtimeZi());
//----------------------------------------------------------
	this->set_decision(inst.decision());
	this->set_decisionZi(inst.decisionZi());
//----------------------------------------------------------
	this->set_SpeedRate(inst.SpeedRate());
	this->set_SpeedRateZi(inst.SpeedRateZi());
//----------------------------------------------------------
	this->set_Yield(inst.Yield());
	this->set_YieldZi(inst.YieldZi());
//----------------------------------------------------------
	this->set_AutoRate(inst.AutoRate());
	this->set_AutoRateZi(inst.AutoRateZi());
//----------------------------------------------------------
	this->set_Energy(inst.Energy());
	this->set_EnergyZi(inst.EnergyZi());
//----------------------------------------------------------
	this->set_Quality(inst.Quality());
	this->set_QualityZi(inst.QualityZi());
//----------------------------------------------------------
	this->set_AlarmScore(inst.AlarmScore());
	this->set_AlarmScoreZi(inst.AlarmScoreZi());
//----------------------------------------------------------
	this->set_OverallScore(inst.OverallScore());
	this->set_OverallScoreZi(inst.OverallScoreZi());
//----------------------------------------------------------
	this->set_Elong(inst.Elong());
	this->set_ElongZi(inst.ElongZi());
//----------------------------------------------------------
	this->set_TC(inst.TC());
	this->set_TCZi(inst.TCZi());
}
char* T_PDO_LIST::extId() const{
	return((char*)c_extId );
}


void T_PDO_LIST::set_extId( const char* arg ){ 
	strncpy((char*)c_extId , arg , sizeof(c_extId));
	c_extId[sizeof(c_extId)-1] = '\0';
	return;
}


char* T_PDO_LIST::entId() const{
	return((char*)c_entId );
}

short T_PDO_LIST::entIdZi() const{
	return( s_entIdZi);
}

void T_PDO_LIST::set_entId( const char* arg ){ 
	strncpy((char*)c_entId , arg , sizeof(c_entId));
	c_entId[sizeof(c_entId)-1] = '\0';
	s_entIdZi=  0;
	return;
}

void T_PDO_LIST::set_entIdZi( short arg ) {
	s_entIdZi =  arg;
}

char* T_PDO_LIST::steelgrade() const{
	return((char*)c_steelgrade );
}

short T_PDO_LIST::steelgradeZi() const{
	return( s_steelgradeZi);
}

void T_PDO_LIST::set_steelgrade( const char* arg ){ 
	strncpy((char*)c_steelgrade , arg , sizeof(c_steelgrade));
	c_steelgrade[sizeof(c_steelgrade)-1] = '\0';
	s_steelgradeZi=  0;
	return;
}

void T_PDO_LIST::set_steelgradeZi( short arg ) {
	s_steelgradeZi =  arg;
}

long T_PDO_LIST::start() const{
	return((long)l_start );
}

short T_PDO_LIST::startZi() const{
	return( s_startZi);
}

void T_PDO_LIST::set_start( long arg ){ 
	l_start = arg;
	s_startZi=  0;
	return;
}

void T_PDO_LIST::set_startZi( short arg ) {
	s_startZi =  arg;
}

long T_PDO_LIST::end() const{
	return((long)l_end );
}

short T_PDO_LIST::endZi() const{
	return( s_endZi);
}

void T_PDO_LIST::set_end( long arg ){ 
	l_end = arg;
	s_endZi=  0;
	return;
}

void T_PDO_LIST::set_endZi( short arg ) {
	s_endZi =  arg;
}

char* T_PDO_LIST::starttime() const{
	return((char*)c_starttime );
}

short T_PDO_LIST::starttimeZi() const{
	return( s_starttimeZi);
}

void T_PDO_LIST::set_starttime( char* arg ){ 
	strncpy((char*)c_starttime , arg , sizeof(c_starttime));
	c_starttime[sizeof(c_starttime)-1] = '\0';
	s_starttimeZi=  0;
	return;
}

void T_PDO_LIST::set_starttimeZi( short arg ) {
	s_starttimeZi =  arg;
}

char* T_PDO_LIST::endtime() const{
	return((char*)c_endtime );
}

short T_PDO_LIST::endtimeZi() const{
	return( s_endtimeZi);
}

void T_PDO_LIST::set_endtime( char* arg ){ 
	strncpy((char*)c_endtime , arg , sizeof(c_endtime));
	c_endtime[sizeof(c_endtime)-1] = '\0';
	s_endtimeZi=  0;
	return;
}

void T_PDO_LIST::set_endtimeZi( short arg ) {
	s_endtimeZi =  arg;
}

char* T_PDO_LIST::decision() const{
	return((char*)c_decision );
}

short T_PDO_LIST::decisionZi() const{
	return( s_decisionZi);
}

void T_PDO_LIST::set_decision( const char* arg ){ 
	strncpy((char*)c_decision , arg , sizeof(c_decision));
	c_decision[sizeof(c_decision)-1] = '\0';
	s_decisionZi=  0;
	return;
}

void T_PDO_LIST::set_decisionZi( short arg ) {
	s_decisionZi =  arg;
}

long T_PDO_LIST::SpeedRate() const{
	return((long)l_SpeedRate );
}

short T_PDO_LIST::SpeedRateZi() const{
	return( s_SpeedRateZi);
}

void T_PDO_LIST::set_SpeedRate( long arg ){ 
	l_SpeedRate = arg;
	s_SpeedRateZi=  0;
	return;
}

void T_PDO_LIST::set_SpeedRateZi( short arg ) {
	s_SpeedRateZi =  arg;
}

long T_PDO_LIST::Yield() const{
	return((long)l_Yield );
}

short T_PDO_LIST::YieldZi() const{
	return( s_YieldZi);
}

void T_PDO_LIST::set_Yield( long arg ){ 
	l_Yield = arg;
	s_YieldZi=  0;
	return;
}

void T_PDO_LIST::set_YieldZi( short arg ) {
	s_YieldZi =  arg;
}

long T_PDO_LIST::AutoRate() const{
	return((long)l_AutoRate );
}

short T_PDO_LIST::AutoRateZi() const{
	return( s_AutoRateZi);
}

void T_PDO_LIST::set_AutoRate( long arg ){ 
	l_AutoRate = arg;
	s_AutoRateZi=  0;
	return;
}

void T_PDO_LIST::set_AutoRateZi( short arg ) {
	s_AutoRateZi =  arg;
}

long T_PDO_LIST::Energy() const{
	return((long)l_Energy );
}

short T_PDO_LIST::EnergyZi() const{
	return( s_EnergyZi);
}

void T_PDO_LIST::set_Energy( long arg ){ 
	l_Energy = arg;
	s_EnergyZi=  0;
	return;
}

void T_PDO_LIST::set_EnergyZi( short arg ) {
	s_EnergyZi =  arg;
}

long T_PDO_LIST::Quality() const{
	return((long)l_Quality );
}

short T_PDO_LIST::QualityZi() const{
	return( s_QualityZi);
}

void T_PDO_LIST::set_Quality( long arg ){ 
	l_Quality = arg;
	s_QualityZi=  0;
	return;
}

void T_PDO_LIST::set_QualityZi( short arg ) {
	s_QualityZi =  arg;
}

long T_PDO_LIST::AlarmScore() const{
	return((long)l_AlarmScore );
}

short T_PDO_LIST::AlarmScoreZi() const{
	return( s_AlarmScoreZi);
}

void T_PDO_LIST::set_AlarmScore( long arg ){ 
	l_AlarmScore = arg;
	s_AlarmScoreZi=  0;
	return;
}

void T_PDO_LIST::set_AlarmScoreZi( short arg ) {
	s_AlarmScoreZi =  arg;
}

char* T_PDO_LIST::OverallScore() const{
	return((char*)c_OverallScore );
}

short T_PDO_LIST::OverallScoreZi() const{
	return( s_OverallScoreZi);
}

void T_PDO_LIST::set_OverallScore( const char* arg ){ 
	strncpy((char*)c_OverallScore , arg , sizeof(c_OverallScore));
	c_OverallScore[sizeof(c_OverallScore)-1] = '\0';
	s_OverallScoreZi=  0;
	return;
}

void T_PDO_LIST::set_OverallScoreZi( short arg ) {
	s_OverallScoreZi =  arg;
}

char* T_PDO_LIST::Elong() const{
	return((char*)c_Elong );
}

short T_PDO_LIST::ElongZi() const{
	return( s_ElongZi);
}

void T_PDO_LIST::set_Elong( const char* arg ){ 
	strncpy((char*)c_Elong , arg , sizeof(c_Elong));
	c_Elong[sizeof(c_Elong)-1] = '\0';
	s_ElongZi=  0;
	return;
}

void T_PDO_LIST::set_ElongZi( short arg ) {
	s_ElongZi =  arg;
}

char* T_PDO_LIST::TC() const{
	return((char*)c_TC );
}

short T_PDO_LIST::TCZi() const{
	return( s_TCZi);
}

void T_PDO_LIST::set_TC( char* arg ){ 
	strncpy((char*)c_TC , arg , sizeof(c_TC));
	c_TC[sizeof(c_TC)-1] = '\0';
	s_TCZi=  0;
	return;
}

void T_PDO_LIST::set_TCZi( short arg ) {
	s_TCZi =  arg;
}

// methodes for Primary key
char* T_PDO_LIST::k_extId(){
	return((char*)c_k_extId );
}

void T_PDO_LIST::set_k_extId( char* arg ){
	strncpy((char*)c_k_extId , arg , sizeof(c_k_extId));
	c_k_extId[sizeof(c_k_extId)-1] = '\0';
	return;
}

//
//	 public methode fillStructure
//
//	this methode filles the classstructue with the private attributes
//
void T_PDO_LIST::fillStructure(){
	strncpy ( structTable.extId , extId(),sizeof(structTable.extId));
	strncpy ( structTable.entId , entId(),sizeof(structTable.entId));
	strncpy ( structTable.steelgrade , steelgrade(),sizeof(structTable.steelgrade));
	structTable.start = start();
	structTable.end = end();
	strncpy ( structTable.starttime , starttime(),sizeof(structTable.starttime));
	strncpy ( structTable.endtime , endtime(),sizeof(structTable.endtime));
	strncpy ( structTable.decision , decision(),sizeof(structTable.decision));
	structTable.SpeedRate = SpeedRate();
	structTable.Yield = Yield();
	structTable.AutoRate = AutoRate();
	structTable.Energy = Energy();
	structTable.Quality = Quality();
	structTable.AlarmScore = AlarmScore();
	strncpy ( structTable.OverallScore , OverallScore(),sizeof(structTable.OverallScore));
	strncpy ( structTable.Elong , Elong(),sizeof(structTable.Elong));
	strncpy ( structTable.TC , TC(),sizeof(structTable.TC));
	return;
}
///////////////////////////////////////////////////
void T_PDO_LIST::fillStructureZi(){
	structTableZi.entIdZi = entIdZi();
	structTableZi.steelgradeZi = steelgradeZi();
	structTableZi.startZi = startZi();
	structTableZi.endZi = endZi();
	structTableZi.starttimeZi = starttimeZi();
	structTableZi.endtimeZi = endtimeZi();
	structTableZi.decisionZi = decisionZi();
	structTableZi.SpeedRateZi = SpeedRateZi();
	structTableZi.YieldZi = YieldZi();
	structTableZi.AutoRateZi = AutoRateZi();
	structTableZi.EnergyZi = EnergyZi();
	structTableZi.QualityZi = QualityZi();
	structTableZi.AlarmScoreZi = AlarmScoreZi();
	structTableZi.OverallScoreZi = OverallScoreZi();
	structTableZi.ElongZi = ElongZi();
	structTableZi.TCZi = TCZi();
	return;
}
///////////////////////////////////////////////////
void T_PDO_LIST::setStructure() {
	set_entId( structTable.entId);
	set_steelgrade( structTable.steelgrade);
	set_start( structTable.start);
	set_end( structTable.end);
	set_starttime( structTable.starttime);
	set_endtime( structTable.endtime);
	set_decision( structTable.decision);
	set_SpeedRate( structTable.SpeedRate);
	set_Yield( structTable.Yield);
	set_AutoRate( structTable.AutoRate);
	set_Energy( structTable.Energy);
	set_Quality( structTable.Quality);
	set_AlarmScore( structTable.AlarmScore);
	set_OverallScore( structTable.OverallScore);
	set_Elong( structTable.Elong);
	set_TC( structTable.TC);
	return;
}
///////////////////////////////////////////////////
void T_PDO_LIST::setStructureZi() {
	set_entIdZi( structTableZi.entIdZi);
	set_steelgradeZi( structTableZi.steelgradeZi);
	set_startZi( structTableZi.startZi);
	set_endZi( structTableZi.endZi);
	set_starttimeZi( structTableZi.starttimeZi);
	set_endtimeZi( structTableZi.endtimeZi);
	set_decisionZi( structTableZi.decisionZi);
	set_SpeedRateZi( structTableZi.SpeedRateZi);
	set_YieldZi( structTableZi.YieldZi);
	set_AutoRateZi( structTableZi.AutoRateZi);
	set_EnergyZi( structTableZi.EnergyZi);
	set_QualityZi( structTableZi.QualityZi);
	set_AlarmScoreZi( structTableZi.AlarmScoreZi);
	set_OverallScoreZi( structTableZi.OverallScoreZi);
	set_ElongZi( structTableZi.ElongZi);
	set_TCZi( structTableZi.TCZi);
	return;
}
///////////////////////////////////////////////////
char* T_PDO_LIST::getName(){
	return((char*)"T_PDO_LIST");
}
///////////////////////////////////////////////////
int T_PDO_LIST::getSqlCode(){
	return( db.dbSqlCode);
}
int T_PDO_LIST::getRowsProcessed(){
	return( db.dbRowsProcessed);
}