C++ checkResults函数代码示例

const char* CppSQLite3Table::fieldName(int nCol)
{
	checkResults();

	if (nCol < 0 || nCol > mnCols-1)
	{
		throw CppSQLite3Exception(CPPSQLITE_ERROR,"Invalid field index requested",DONT_DELETE_MSG);
	}

	return mpaszResults[nCol];
}

void show_sched_param(pthread_attr_t *a) {
	int rc = 0;
	struct sched_param param;

	rc = mythread_attr_getschedparam(a, &param);
	checkResults("pthread_attr_getschedparam()\n", rc);

	printf("param.sched_priority = %d\n",
			param.__sched_priority);
	return;
}

void *theThread(void *parm)
{
   int               rc;
   threadSpecific_data_t    *gData;
   printf("Thread %.8x %.8x: Entered\n", pthread_self());
   gData = (threadSpecific_data_t *)parm;
   rc = pthread_setspecific(threadSpecificKey, gData);
   checkResults("pthread_setspecific()\n", rc);
   foo();
   return NULL;
}

void *theThread(void *parm)
{
	int   rc;
	rc = pthread_mutex_lock(&mutex);
	printf("Thread %u: Entered\n",(unsigned int ) pthread_self());
	checkResults("pthread_mutex_lock()\n", rc);

	/********** Critical Section *******************/
	printf("Thread %u: Start critical section, holding lock\n",(unsigned int ) pthread_self());

	/* Access to shared data goes here */
	sharedData++; 
	sharedData2--;
	printf("Thread %u: End critical section, release lock\n", (unsigned int )pthread_self());

	/********** Critical Section *******************/
	rc = pthread_mutex_unlock(&mutex);
	checkResults("pthread_mutex_unlock()\n", rc);
	return NULL;
}

const char* CppSQLite3Table::fieldValue(int nField)
{
	checkResults();

	if (nField < 0 || nField > mnCols-1)
	{
		IwError(("Invalid field index requested"));
	}

	int nIndex = (mnCurrentRow*mnCols) + mnCols + nField;
	return mpaszResults[nIndex];
}

void CppSQLite3Table::setRow(int nRow)
{
	checkResults();

	if (nRow < 0 || nRow > mnRows-1)
	{
		throw CppSQLite3Exception(CPPSQLITE_ERROR,
								"Invalid row index requested",
								DONT_DELETE_MSG);
	}

	mnCurrentRow = nRow;
}

int main(int argc, char **argv)
{
	int                   rc=0;
	int                   i;
	pthread_t             threadid[NTHREADS];

	printf("Enter Testcase - %s\n", argv[0]);

	printf("Create %d threads\n", NTHREADS);
	for(i=0; i<NTHREADS; ++i) {
	  	rc = pthread_create(&threadid[i], NULL, threadfunc, NULL);
	  	checkResults("pthread_create()\n", rc);
	}

	sleep(5);  /* Sleep is not a very robust way to serialize threads */
	rc = pthread_mutex_lock(&mutex);
	checkResults("pthread_mutex_lock()\n", rc);

	/* The condition has occured. Set the flag and wake up any waiting threads */
	conditionMet = 1;
	printf("Wake up all waiting threads...\n");
	rc = pthread_cond_broadcast(&cond);
	checkResults("pthread_cond_broadcast()\n", rc);

	rc = pthread_mutex_unlock(&mutex);
	checkResults("pthread_mutex_unlock()\n", rc);

	printf("Wait for threads and cleanup\n");
	for (i=0; i<NTHREADS; ++i) {
	  	rc = pthread_join(threadid[i], NULL);
	  	checkResults("pthread_join()\n", rc);
	}

	pthread_cond_destroy(&cond);
	pthread_mutex_destroy(&mutex);

	printf("Main completed\n");
	return 0;
}

int main (int argc,char * argv[])
{

    pthread_t       *threads;
    pthread_attr_t  pta;
    int             iteration,THREADS,ret_count;
    char 		* CLASS;

    double          time_start, time_end;
    struct          timeval tv;
    struct          timezone tz;

    int counter;
    printf("\n\t\t Objective : To compute the minimum of a list of numbers using mutex. \n ");

    if( argc != 3 )                                                       // check command line arguments
    {
        printf("\t\t Very Few Arguments\n ");
        printf("\t\t Syntax : exec <NumElements> <Threads>\n");
        exit(-1);
    }												// user input
    else {
        NumElements =atoi( argv[1]);
        THREADS = atoi(argv[2]);
    }

    NumThreads = THREADS;
    printf("\n\t\t Array Size  :  %ld",NumElements);
    printf("\n\t\t Threads     :  %d",NumThreads);
    printf("\n");

    if (NumThreads < 1 )
    {
        printf("\n Number of threads must be greater than zero. Aborting ...\n");
        return 0;
    }

    if ((NumThreads != 1) && (NumThreads != 2) && (NumThreads != 4) && (NumThreads != 8))
    {
        printf("\n Number of Threads must be 1 or 2 or 4 or 8. Aborting ...\n");
        return 0;
    }

    if ( ( NumElements % NumThreads ) != 0 )
    {
        printf("\n Number of threads not a factor of Integer List size. Aborting.\n");
        return 0 ;
    }


    partial_list_size = NumElements / NumThreads;                                 // define partial size for each thread

    list = (long int *)malloc(sizeof(long int) * NumElements);


    for(counter = 0 ; counter < NumElements ; counter++)
    {
        srand48((unsigned int)NumElements);							// random number generation
        list[counter] = (rand()%1000)+1.0;
    }

    threads = (pthread_t *)malloc(sizeof(pthread_t)*NumThreads);

    minimum_value = list[0];

    ret_count=pthread_mutex_init(&minimum_value_lock, NULL);
    checkResults("pthread_mutex_init()\n", ret_count);


    ret_count=pthread_attr_init(&pta);
    checkResults("pthread_attr_init()\n", ret_count);

    pthread_attr_setscope(&pta,PTHREAD_SCOPE_SYSTEM);

    gettimeofday(&tv, &tz);
    time_start = (double)tv.tv_sec + (double)tv.tv_usec / 1000000.0;


    for(counter = 0 ; counter < NumThreads ; counter++)
    {
        ret_count=pthread_create(&threads[counter],&pta,(void *(*) (void *)) find_min_rwlock,(void *) (counter+1));     // call find_min_rwlock function
        checkResults("pthread_create()\n", ret_count);
    }

    gettimeofday(&tv, &tz);
    time_end = (double)tv.tv_sec + (double)tv.tv_usec / 1000000.0;



    for(counter = 0 ; counter < NumThreads ; counter++)
    {
        ret_count=pthread_join(threads[counter],NULL);
        checkResults("pthread_join()\n", ret_count);
    }
    ret_count=pthread_attr_destroy(&pta);
    checkResults("pthread_attr_destroy()\n", ret_count);

    printf("\n\t\t..........................................................................\n");
    printf("\n\t\t Minimum Value found in the Integer list     :  %d",minimum_value);
    printf("\n\t\t Time Taken in Seconds  (T)                  :  %lf Seconds",( time_end - time_start));
//.........这里部分代码省略.........

int main(int argc, char *argv[]) {

  int i;

#ifdef EPETRA_MPI
  // Initialize MPI
  MPI_Init(&argc,&argv);
  Epetra_MpiComm comm(MPI_COMM_WORLD);
#else
  Epetra_SerialComm comm;
#endif

  // Uncomment to debug in parallel int tmp; if (comm.MyPID()==0) cin >> tmp; comm.Barrier();

  bool verbose = false;
  bool veryVerbose = false;

  // Check if we should print results to standard out
  if (argc>1) if (argv[1][0]=='-' && argv[1][1]=='v') verbose = true;

  if (!verbose) comm.SetTracebackMode(0); // This should shut down any error traceback reporting

  if (verbose) cout << comm << endl << flush;

  bool verbose1 = verbose;
  if (verbose) verbose = (comm.MyPID()==0);

  int nx = 4;
  int ny = comm.NumProc()*nx; // Scale y grid with number of processors
  
  // Create funky stencil to make sure the matrix is non-symmetric (transpose non-trivial):

  // (i-1,j-1) (i-1,j  )
  // (i  ,j-1) (i  ,j  ) (i  ,j+1)
  // (i+1,j-1) (i+1,j  )
  
  int npoints = 2;

  int xoff[] = {-1,  0,  1, -1,  0,  1,  0};
  int yoff[] = {-1, -1, -1,  0,  0,  0,  1};

  Epetra_Map * map;
  Epetra_CrsMatrix * A;
  Epetra_Vector * x, * b, * xexact;
	
  Trilinos_Util_GenerateCrsProblem(nx, ny, npoints, xoff, yoff, comm, map, A, x, b, xexact);

  if (verbose) 
    cout << "npoints = " << npoints << " nx = " << nx << " ny = " << ny  << endl ; 

  if (verbose && nx<6 ) {
    cout << *A << endl;
    cout << "B       = " << endl << *b << endl;
  }
  // Construct linear problem object
  
  Epetra_LinearProblem origProblem(A, x, b);
  Epetra_LinearProblem *redistProblem;
  
  Epetra_Time timer(comm);
  
  // Construct redistor object, use all processors and replicate full problem on each

  double start = timer.ElapsedTime();
  Epetra_LinearProblemRedistor redistor(&origProblem, comm.NumProc(), true);
  if (verbose) cout << "\nTime to construct redistor  = " 
		    << timer.ElapsedTime() - start << endl;

  bool ConstructTranspose = true; 
  bool MakeDataContiguous = true;
  
  start = timer.ElapsedTime();
  redistor.CreateRedistProblem(ConstructTranspose, MakeDataContiguous, redistProblem);
  if (verbose) cout << "\nTime to create redistributed problem = " 
		    << timer.ElapsedTime() - start << endl;
  
  
  // Now test output of redistor by performing matvecs

  int ierr = 0;
  ierr += checkResults( ConstructTranspose, &redistor, &origProblem, 
			redistProblem, verbose);
  
  
  // Now change values in original rhs and test update facility of redistor
  // Multiply b by 2
  
  double Value = 2.0;
  
  b->Scale(Value); // b = 2*b
  
  redistor.UpdateRedistRHS(b);
  if (verbose) cout << "\nTime to update redistributed RHS  = " 
		    << timer.ElapsedTime() - start << endl;
  
  ierr += checkResults( ConstructTranspose, &redistor, 
			&origProblem, redistProblem, verbose);
 
  // Now change values in original matrix and test update facility of redistor

//.........这里部分代码省略.........

// EXCEPTIONS: CProcessFailure
void CPCPATRDllProcess::processANAFile(CProcessStatus& status)
{
  CModelFilesSet* pSourceMFS = status.getInputMFS();
  ASSERTX(pSourceMFS);
  CModelFilesSet* pTargetMFS = status.getOutputMFS(); // may be null

  try
	{
	  IPatrParser *pPatr;
	  CLSID clsid;
	  HRESULT hr;

#ifndef hab245
	  CString sBase;
	  sBase.Format(_T("%s%d"), (LPCTSTR)getTempFileNameBase(status), status.m_iProcNumber);
#else // hab245
	  CString sBase = getTempFileNameBase(status);
#endif // hab245
	  m_sOutPath = status.makeTempPath(sBase,	_T(".ana") );
	  m_sLOGPath = status.makeTempPath(sBase,	_T(".log") );

	  m_sInPath = status.sANAPath;
	  m_sOutPath.deleteFile();
	  m_sLOGPath.deleteFile();

	  hr = CoInitialize(NULL);
#ifndef hab245
	  checkResults(hr, _T("coinitialize"), (IPatrParser *)NULL);
	  hr = CLSIDFromProgID(L"SIL.CARLA.PatrParser.1", &clsid);
	  checkResults(hr, _T("get CLSID"), (IPatrParser *)NULL);
	  hr = CoCreateInstance(clsid, NULL, CLSCTX_ALL,
				IID_IPatrParser, (void **) &pPatr);
	  checkResults(hr, _T("do CoCreateInstance"), (IPatrParser *)NULL);
	  CString s = m_sLOGPath.getQuotedPath();
	  CString sLogFile = s.Mid(1, s.GetLength()-2);
	  hr = pPatr->OpenLog(sLogFile.AllocSysString());
	  checkResults(hr, _T("set log file"), (IPatrParser *)NULL);
	  hr = pPatr->Clear();
	  checkResults(hr, _T("clear"), pPatr);
	  hr = pPatr->put_CommentChar(status.getInputMFS()->getCommentChar());
	  checkResults(hr, _T("set comment character"), pPatr);
	  hr = pPatr->put_AmplePropertyIsFeature(m_bAmplePropertyIsFeature);
	  checkResults(hr, _T("set AmplePropertyIsFeature"), pPatr);
	  hr = pPatr->put_PromoteDefaultAtoms(m_bPromoteDefaultAtomicValues);
	  checkResults(hr, _T("set PromoteDefaultAtoms"), pPatr);
	  hr = pPatr->put_Failures(m_bShowFailures);
	  checkResults(hr, _T("set Failures"), pPatr);
	  hr = pPatr->put_DisplayFeatures(m_bDisplayFeatures);
	  checkResults(hr, _T("set DisplayFeatures"), pPatr);
	  hr = pPatr->put_TopFeatureOnly(!m_bAllFeatures);
	  checkResults(hr, _T("set TopFeatureOnly"), pPatr);
	  hr = pPatr->put_Gloss(m_bDisplayGloss);
	  checkResults(hr, _T("set Gloss"), pPatr);
	  hr = pPatr->put_TrimEmptyFeatures(m_bTrimEmptyFeatures);
	  checkResults(hr, _T("set TrimEmptyFeatures"), pPatr);
	  hr = pPatr->put_Unification(m_bPerformUnification);
	  checkResults(hr, _T("set Unification"), pPatr);
	  hr = pPatr->put_WriteAmpleParses(m_bWriteAmpleParses);
	  checkResults(hr, _T("set WriteAmpleParses"), pPatr);
	  hr = pPatr->put_MaxAmbiguity(m_uiMaxAmbiguities);
	  checkResults(hr, _T("set MaxAmbiguity"), pPatr);
#ifndef rde273
	  hr = pPatr->put_CodePage(GetCSAcp());
#endif  // rde273
	  hr = pPatr->put_SentenceFinalPunctuation(
				 m_sSentenceFinalPunctuation.AllocSysString());
	  checkResults(hr, _T("set SentenceFinalPunctuation"), pPatr);
	  hr = pPatr->put_TimeLimit(m_uiTimeLimit);
	  checkResults(hr, _T("set TimeLimit"), pPatr);
	  hr = pPatr->put_TreeDisplay(m_iTreeDisplayFormat);
	  checkResults(hr, _T("set TreeDisplay"), pPatr);
	  hr = pPatr->put_FlatFeatureDisplay(m_bFlatFeatureDisplay);
	  checkResults(hr, _T("set FlatFeatureDisplay"), pPatr);

#ifndef hab262
	  if (m_iRootGlossSetting > 0)
	m_iRootGlossSetting++;	// need to adjust value to get correct setting
	  hr = pPatr->put_RootGlossFeature(m_iRootGlossSetting);
	  if (m_iRootGlossSetting > 0)
	m_iRootGlossSetting--;	// adjust the value back
	  checkResults(hr, _T("set RootGlossFeature"), pPatr);
#endif // hab262
	  hr = pPatr->LoadGrammarFile(m_sGrammarFileName.AllocSysString());
	  checkResults(hr, _T("load grammar file.\nSee Log File."), pPatr);
	  s = m_sOutPath.getQuotedPath();;
	  CString sOutFile = s.Mid(1, s.GetLength()-2);
	  hr = pPatr->DisambiguateAnaFile(m_sInPath.getShortPath().AllocSysString(),
					  sOutFile.AllocSysString());
	  checkResults(hr, _T("disambiguate ANA file"), pPatr);
	  hr = pPatr->CloseLog();
	  checkResults(hr, _T("close log file"), pPatr);
#else // hab245

	  checkResults(hr, _T("coinitialize"));
	  hr = CLSIDFromProgID(L"SIL.CARLA.PatrParser.1", &clsid);
	  checkResults(hr, "get CLSID");
	  hr = CoCreateInstance(clsid, NULL, CLSCTX_ALL,
				IID_IPatrParser, (void **) &pPatr);
	  checkResults(hr, "do CoCreateInstance");
//.........这里部分代码省略.........

void Database_PostgreSQL::endSave()
{
	checkResults(PQexec(m_conn, "COMMIT;"));
}

void benchmark(int samples = 1)
{
	std::cout << std::string(70, '-') << std::endl
	          << getTypeName<T>()
	          << " conversion (size = " << sizeof(T)*8 << " bits) - ";

	std::vector<std::string> strings = generateRandStrings<T>(numNumbers);

	std::cout << std::string(70, '-') << std::endl;

	////
	std::cout << "  stringstream: ";
	if (checkResults(strings, stringstream_convert<T>))
		time_run<T>(strings, stringstream_convert<T>, samples);
	else
		std::cout << "FAILURE" << std::endl;

	////
	std::cout << "        sscanf: ";
	if (checkResults(strings, sscanf_convert<T>))
		time_run<T>(strings, sscanf_convert<T>, samples);
	else
		std::cout << "FAILURE" << std::endl;

	////
	std::cout << "          stoi: ";
	if (sizeof(T) > sizeof(int))
		std::cout << "SKIPPED" << std::endl;
	else if (checkResults(strings, stoi_convert<T>))
		time_run<T>(strings, stoi_convert<T>, samples);
	else
		std::cout << "FAILURE" << std::endl;

	////
	std::cout << "        strtol: ";
	if (sizeof(T) > sizeof(long))
		std::cout << "SKIPPED" << std::endl;
	else if (checkResults(strings, strtol_convert<T>))
		time_run<T>(strings, strtol_convert<T>, samples);
	else
		std::cout << "FAILURE" << std::endl;

	std::cout << "          stol: ";
	if (sizeof(T) > sizeof(long))
		std::cout << "SKIPPED" << std::endl;
	else if (checkResults(strings, stol_convert<T>))
		time_run<T>(strings, stol_convert<T>, samples);
	else
		std::cout << "FAILURE" << std::endl;

	std::cout << "       strtoll: ";
	if (sizeof(T) > sizeof(long long))
		std::cout << "SKIPPED" << std::endl;
	else if (checkResults(strings, strtoll_convert<T>))
		time_run<T>(strings, strtoll_convert<T>, samples);
	else
		std::cout << "FAILURE" << std::endl;

	std::cout << "         stoll: ";
	if (sizeof(T) > sizeof(long long))
		std::cout << "SKIPPED" << std::endl;
	else if (checkResults(strings, stoll_convert<T>))
		time_run<T>(strings, stoll_convert<T>, samples);
	else
		std::cout << "FAILURE" << std::endl;

	std::cout << "     handcoded: ";
	if (checkResults(strings, handcoded_convert<T>))
		time_run<T>(strings, handcoded_convert<T>, samples);
	else
		std::cout << "FAILURE" << std::endl;


	std::cout << "        hybrid: ";
	if (checkResults(strings, hybrid_convert<T>))
		time_run<T>(strings, hybrid_convert<T>, samples);
	else
		std::cout << "FAILURE" << std::endl;

}

int main(int argc, char *argv[])
{
  int i;

#ifdef EPETRA_MPI
  // Initialize MPI
  MPI_Init(&argc,&argv);
  Epetra_MpiComm comm(MPI_COMM_WORLD);
#else
  Epetra_SerialComm comm;
#endif

  // Uncomment to debug in parallel int tmp; if (comm.MyPID()==0) cin >> tmp; comm.Barrier();

  bool verbose = false;

  // Check if we should print results to standard out
  if (argc>1) if (argv[1][0]=='-' && argv[1][1]=='v') verbose = true;

  if (!verbose) comm.SetTracebackMode(0); // This should shut down any error traceback reporting

  if (verbose) cout << comm << endl << flush;

  if (verbose) verbose = (comm.MyPID()==0);

  if (verbose)
    cout << EpetraExt::EpetraExt_Version() << endl << endl;

  int nx = 128;
  int ny = comm.NumProc()*nx; // Scale y grid with number of processors

  // Create funky stencil to make sure the matrix is non-symmetric (transpose non-trivial):

  // (i-1,j-1) (i-1,j  )
  // (i  ,j-1) (i  ,j  ) (i  ,j+1)
  // (i+1,j-1) (i+1,j  )

  int npoints = 7;

  int xoff[] = {-1,  0,  1, -1,  0,  1,  0};
  int yoff[] = {-1, -1, -1,  0,  0,  0,  1};

  Epetra_Map * map;
  Epetra_CrsMatrix * A;
  Epetra_Vector * x, * b, * xexact;
	
  Trilinos_Util_GenerateCrsProblem(nx, ny, npoints, xoff, yoff, comm, map, A, x, b, xexact);

  if (nx<8)
  {
    cout << *A << endl;
    cout << "X exact = " << endl << *xexact << endl;
    cout << "B       = " << endl << *b << endl;
  }

  // Construct transposer 
  Epetra_Time timer(comm);

  double start = timer.ElapsedTime();

  //bool IgnoreNonLocalCols = false;
  bool MakeDataContiguous = true;
  EpetraExt::RowMatrix_Transpose transposer( MakeDataContiguous );

  if (verbose) cout << "\nTime to construct transposer  = " << timer.ElapsedTime() - start << endl;
  
  Epetra_CrsMatrix & transA = dynamic_cast<Epetra_CrsMatrix&>(transposer(*A));

  start = timer.ElapsedTime();
  if (verbose) cout << "\nTime to create transpose matrix  = " << timer.ElapsedTime() - start << endl;
 	
  // Now test output of transposer by performing matvecs
  int ierr = 0;
  ierr += checkResults(A, &transA, xexact, verbose);


  // Now change values in original matrix and test update facility of transposer
  // Add 2 to the diagonal of each row
  double Value = 2.0;
  for (i=0; i< A->NumMyRows(); i++)
  A->SumIntoMyValues(i, 1, &Value, &i);

  start = timer.ElapsedTime();
  transposer.fwd();

  if (verbose) cout << "\nTime to update transpose matrix  = " << timer.ElapsedTime() - start << endl;
 	
  ierr += checkResults(A, &transA, xexact, verbose);

  delete A;
  delete b;
  delete x;
  delete xexact;
  delete map;

  if (verbose) cout << endl << "Checking transposer for VbrMatrix objects" << endl<< endl;

  int nsizes = 4;
  int sizes[] = {4, 6, 5, 3};

//.........这里部分代码省略.........

//.........这里部分代码省略.........
#endif
#ifdef _WIN32
			std::sort(dataSTL, dataSTL + N);
#endif
			stlTimes.timerEnd(t-1);
		}

#if FLUSH_CACHE==1
#ifdef linux
                cf.flush();
#endif
#endif
#endif

// radix sort V1
		for (it = 0; it < repetitions; it++) {
			setThreadsNo(t, maxThreads);
#pragma omp parallel for private(i) default(shared)

			for (i = 0; i < N; i++){
				dataRadix[i] = dataIn[i];
				key[i]=i;
			}

#if FLUSH_CACHE==1
#ifdef linux
                        cf.flush();
#endif
#endif
			omp_set_num_threads(t);
			radixTimes.timerStart(t-1);
#if TIME_COUNT==1
                        prsort::pradsort<long,int>(dataRadix,key, N, bitCount,&partTimes);
#else
                        prsort::pradsort<long,int>(dataRadix,key, N,bitCount,NULL);
#endif
			radixTimes.timerEnd(t-1);

		}

       
#if CALC_REF==1
		printf("|STL   SORT(th=%2d)  : %1.3fs  |\t", t,
				stlTimes.getTime(t-1));
#endif
#if TIME_COUNT==1
		for (int i = 0; i < TIMERS_COUNT; i++) {
#if CREATE_OUTPUT==1
			printf("%d %d %d %d %d %d %d %f\n", NUMA, NODE_BIND, CPU_BIND, FIRST_TOUCH,bitCount , t, i ,partTimes.getTime(i));
#else
			printf("part%d :%f ", i, partTimes.getTime(i));
#endif

		}
#endif
#if CREATE_OUTPUT ==1
		        printf("%d %d %d %d %d %d calosc %1.3f", NUMA,NODE_BIND,CPU_BIND,FIRST_TOUCH,bitCount, t ,radixTimes.getTime(t-1));
#else
		printf("|RADIX SORT (th=%2d)  : %1.3fs  |\t", t,
				radixTimes.getTime(t-1));
#endif

// Attention: checking result only from the last function usage 

#if CALC_REF==1
		checkResults(dataSTL, dataRadix, N);
#else
		printf("\n");
#endif

#if CHECK_KEY==1
	if(checkKey(dataIn,dataRadix,key,N))printf("Keys are good\n");

#endif
	}

#ifdef linux
	delete[] key;
#if NUMA>0
	numa_free(dataRadix, sizeof(long) * N);
        
#else

	delete[] dataRadix;
#endif
#endif
#ifdef _WIN32
	delete[] dataRadix;
#endif

	delete[] dataIn;
	delete[] dataSTL;
	
#if TIME_COUNT==1
	
        
        
#endif
	return 0;
}

void Database_PostgreSQL::beginSave()
{
	verifyDatabase();
	checkResults(PQexec(m_conn, "BEGIN;"));
}