mirror of
https://github.com/mariadb-corporation/mariadb-columnstore-engine.git
synced 2025-04-18 21:44:02 +03:00
1499 lines
46 KiB
C++
1499 lines
46 KiB
C++
/* Copyright (C) 2014 InfiniDB, Inc.
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License
|
|
as published by the Free Software Foundation; version 2 of
|
|
the License.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
|
|
MA 02110-1301, USA. */
|
|
|
|
// $Id: tdriver-function.cpp 9210 2013-01-21 14:10:42Z rdempsey $
|
|
#include <iostream>
|
|
#include <list>
|
|
#include <sstream>
|
|
#include <pthread.h>
|
|
#include <iomanip>
|
|
#include <cppunit/extensions/HelperMacros.h>
|
|
#include <cppunit/extensions/TestFactoryRegistry.h>
|
|
#include <cppunit/ui/text/TestRunner.h>
|
|
|
|
#include "wsdl.h"
|
|
#include "constantdatalist.h"
|
|
|
|
#include "calpontsystemcatalog.h"
|
|
using namespace execplan;
|
|
|
|
#include "functionoperation.h"
|
|
#include <boost/any.hpp>
|
|
#include <boost/function.hpp>
|
|
#include "bytestream.h"
|
|
#include <time.h>
|
|
#include <sys/time.h>
|
|
#include <cmath>
|
|
#include <boost/any.hpp>
|
|
#include <jobstep.h>
|
|
|
|
#define DEBUG
|
|
|
|
using namespace std;
|
|
using namespace joblist;
|
|
using namespace messageqcpp;
|
|
|
|
// void (*fp) (double, double);
|
|
|
|
// Timer class used by this tdriver to output elapsed times, etc.
|
|
class Timer
|
|
{
|
|
public:
|
|
void start(const string& message)
|
|
{
|
|
if (!fHeaderDisplayed)
|
|
{
|
|
header();
|
|
fHeaderDisplayed = true;
|
|
}
|
|
|
|
gettimeofday(&fTvStart, 0);
|
|
cout << timestr() << " Start " << message << endl;
|
|
}
|
|
|
|
void stop(const string& message)
|
|
{
|
|
time_t now;
|
|
time(&now);
|
|
string secondsElapsed;
|
|
getTimeElapsed(secondsElapsed);
|
|
cout << timestr() << " " << secondsElapsed << " Stop " << message << endl;
|
|
}
|
|
|
|
Timer() : fHeaderDisplayed(false)
|
|
{
|
|
}
|
|
|
|
private:
|
|
struct timeval fTvStart;
|
|
bool fHeaderDisplayed;
|
|
|
|
double getTimeElapsed(string& seconds)
|
|
{
|
|
struct timeval tvStop;
|
|
gettimeofday(&tvStop, 0);
|
|
double secondsElapsed =
|
|
(tvStop.tv_sec + (tvStop.tv_usec / 1000000.0)) - (fTvStart.tv_sec + (fTvStart.tv_usec / 1000000.0));
|
|
ostringstream oss;
|
|
oss << secondsElapsed;
|
|
seconds = oss.str();
|
|
seconds.resize(8, '0');
|
|
return secondsElapsed;
|
|
}
|
|
|
|
string timestr()
|
|
{
|
|
struct tm tm;
|
|
struct timeval tv;
|
|
|
|
gettimeofday(&tv, 0);
|
|
localtime_r(&tv.tv_sec, &tm);
|
|
|
|
ostringstream oss;
|
|
oss << setfill('0') << setw(2) << tm.tm_hour << ':' << setw(2) << tm.tm_min << ':' << setw(2) << tm.tm_sec
|
|
<< '.' << setw(6) << tv.tv_usec;
|
|
return oss.str();
|
|
}
|
|
|
|
void header()
|
|
{
|
|
cout << endl;
|
|
cout << "Time Seconds Activity" << endl;
|
|
}
|
|
};
|
|
|
|
// Timer class used by this tdriver to output elapsed times, etc.
|
|
class MultiTimer
|
|
{
|
|
public:
|
|
void start(const string& message);
|
|
void stop(const string& message);
|
|
void finish()
|
|
{
|
|
// Calculate the total seconds elapsed.
|
|
struct timeval tvStop;
|
|
gettimeofday(&tvStop, 0);
|
|
double totalSeconds =
|
|
(tvStop.tv_sec + (tvStop.tv_usec / 1000000.0)) - (fTvStart.tv_sec + (fTvStart.tv_usec / 1000000.0));
|
|
|
|
cout << endl;
|
|
cout << "Seconds Percentage Calls Description" << endl;
|
|
|
|
// Add a last entry into the vector for total.
|
|
ProcessStats total;
|
|
total.fTotalSeconds = totalSeconds;
|
|
total.fProcess = "Total";
|
|
total.fStartCount = 1;
|
|
fProcessStats.push_back(total);
|
|
|
|
for (uint32_t i = 0; i < fProcessStats.size(); i++)
|
|
{
|
|
if (i == (fProcessStats.size() - 1))
|
|
{
|
|
cout << endl;
|
|
}
|
|
|
|
// Seconds.
|
|
string seconds;
|
|
ostringstream oss;
|
|
oss << fProcessStats[i].fTotalSeconds;
|
|
seconds = oss.str();
|
|
seconds.resize(7, '0');
|
|
cout << seconds << " ";
|
|
|
|
// Percentage.
|
|
string percentage;
|
|
ostringstream oss2;
|
|
oss2 << (fProcessStats[i].fTotalSeconds / totalSeconds) * 100.0;
|
|
percentage = oss2.str();
|
|
percentage.resize(5, ' ');
|
|
cout << percentage << "% ";
|
|
|
|
// Times Initiated.
|
|
ostringstream oss3;
|
|
oss3 << fProcessStats[i].fStartCount;
|
|
string timesInitiated = oss3.str();
|
|
timesInitiated.resize(10, ' ');
|
|
cout << timesInitiated << " ";
|
|
|
|
// Description.
|
|
cout << fProcessStats[i].fProcess << endl;
|
|
}
|
|
}
|
|
MultiTimer() : fStarted(false){};
|
|
|
|
private:
|
|
class ProcessStats
|
|
{
|
|
public:
|
|
string fProcess;
|
|
struct timeval fTvProcessStarted;
|
|
double fTotalSeconds;
|
|
long fStartCount;
|
|
long fStopCount;
|
|
|
|
ProcessStats() : fProcess(""), fTotalSeconds(0.0), fStartCount(0), fStopCount(0){};
|
|
|
|
void processStart()
|
|
{
|
|
gettimeofday(&fTvProcessStarted, 0);
|
|
fStartCount++;
|
|
}
|
|
|
|
void processStop()
|
|
{
|
|
struct timeval tvStop;
|
|
gettimeofday(&tvStop, 0);
|
|
fStopCount++;
|
|
fTotalSeconds += (tvStop.tv_sec + (tvStop.tv_usec / 1000000.0)) -
|
|
(fTvProcessStarted.tv_sec + (fTvProcessStarted.tv_usec / 1000000.0));
|
|
}
|
|
};
|
|
|
|
struct timeval fTvStart;
|
|
vector<ProcessStats> fProcessStats;
|
|
bool fStarted;
|
|
};
|
|
|
|
void MultiTimer::stop(const string& message)
|
|
{
|
|
bool found = false;
|
|
uint32_t idx = 0;
|
|
|
|
for (uint32_t i = 0; i < fProcessStats.size(); i++)
|
|
{
|
|
if (fProcessStats[i].fProcess == message)
|
|
{
|
|
idx = i;
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!found)
|
|
{
|
|
throw std::runtime_error("MultiTimer::stop " + message + " called without calling start first.");
|
|
}
|
|
|
|
fProcessStats[idx].processStop();
|
|
}
|
|
|
|
void MultiTimer::start(const string& message)
|
|
{
|
|
bool found = false;
|
|
uint32_t idx = 0;
|
|
ProcessStats processStats;
|
|
|
|
if (!fStarted)
|
|
{
|
|
fStarted = true;
|
|
gettimeofday(&fTvStart, 0);
|
|
}
|
|
|
|
for (uint32_t i = 0; i < fProcessStats.size(); i++)
|
|
{
|
|
if (fProcessStats[i].fProcess == message)
|
|
{
|
|
idx = i;
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!found)
|
|
{
|
|
fProcessStats.push_back(processStats);
|
|
idx = fProcessStats.size() - 1;
|
|
}
|
|
|
|
fProcessStats[idx].fProcess = message;
|
|
fProcessStats[idx].processStart();
|
|
}
|
|
|
|
class functionDriver : public CppUnit::TestFixture
|
|
{
|
|
CPPUNIT_TEST_SUITE(functionDriver);
|
|
CPPUNIT_TEST(FUNCTION_TEST);
|
|
CPPUNIT_TEST_SUITE_END();
|
|
|
|
private:
|
|
ResourceManager fRm;
|
|
|
|
void testDrdFunctions()
|
|
{
|
|
cout << endl;
|
|
cout << "double f(double) functions" << endl;
|
|
cout << "---------------------------" << endl;
|
|
|
|
FunctionOperation* fop = FunctionOperation::instance();
|
|
|
|
// functions to test
|
|
list<string> functionsToTest;
|
|
functionsToTest.push_back("abs");
|
|
functionsToTest.push_back("acos");
|
|
functionsToTest.push_back("asin");
|
|
functionsToTest.push_back("atan");
|
|
functionsToTest.push_back("ceil");
|
|
functionsToTest.push_back("cos");
|
|
functionsToTest.push_back("cosh");
|
|
functionsToTest.push_back("exp");
|
|
functionsToTest.push_back("floor");
|
|
functionsToTest.push_back("ln");
|
|
functionsToTest.push_back("log2");
|
|
functionsToTest.push_back("log10");
|
|
functionsToTest.push_back("sin");
|
|
functionsToTest.push_back("sinh");
|
|
functionsToTest.push_back("sqrt");
|
|
functionsToTest.push_back("tan");
|
|
functionsToTest.push_back("tanh");
|
|
|
|
// type vector is the same for drd functions
|
|
vector<FunctionDataList::FuncDataListType> types;
|
|
types.push_back(FunctionDataList::DOUBLE_LISTTYPE);
|
|
types.push_back(FunctionDataList::DOUBLE_LISTTYPE);
|
|
|
|
int numRows = 1;
|
|
DoubleElementType el0, el1;
|
|
list<string>::iterator it;
|
|
|
|
for (it = functionsToTest.begin(); it != functionsToTest.end(); it++)
|
|
{
|
|
FunctionOperation::Function_t* fp = fop->getFunctionObjPtr(*it, types);
|
|
CPPUNIT_ASSERT(fp);
|
|
WSDL<DoubleElementType>* wsdlOut = new WSDL<DoubleElementType>(1, numRows, fRm);
|
|
WSDL<DoubleElementType>* wsdlIn1 = new WSDL<DoubleElementType>(2, numRows, fRm);
|
|
|
|
for (int i = 0; i < numRows; i++)
|
|
{
|
|
el1.first = i;
|
|
el1.second = (0.5);
|
|
wsdlIn1->insert(el1);
|
|
}
|
|
|
|
wsdlIn1->endOfInput();
|
|
|
|
FunctionDataListSPtr listIn1(new FunctionDataList());
|
|
FunctionDataListSPtr listOut(new FunctionDataList());
|
|
FDLVec parms;
|
|
listOut->doubleDl(wsdlOut);
|
|
listIn1->doubleDl(wsdlIn1);
|
|
parms.push_back(listOut);
|
|
parms.push_back(listIn1);
|
|
fop->executeFunction(fop, fp, parms);
|
|
wsdlOut->endOfInput();
|
|
|
|
int id0 = wsdlOut->getIterator();
|
|
int id1 = wsdlIn1->getIterator();
|
|
|
|
for (int i = 0; i < numRows; i++)
|
|
{
|
|
wsdlIn1->next(id1, &el1);
|
|
wsdlOut->next(id0, &el0);
|
|
cout << *it << "(" << el1.second << ")=" << el0.second << endl;
|
|
}
|
|
}
|
|
}
|
|
|
|
void testDrddFunctions()
|
|
{
|
|
cout << endl;
|
|
cout << "double f(double, double) functions" << endl;
|
|
cout << "---------------------------" << endl;
|
|
|
|
FunctionOperation* fop = FunctionOperation::instance();
|
|
|
|
list<string> functionsToTest;
|
|
functionsToTest.push_back("atan2");
|
|
functionsToTest.push_back("power");
|
|
functionsToTest.push_back("+");
|
|
functionsToTest.push_back("-");
|
|
functionsToTest.push_back("*");
|
|
functionsToTest.push_back("/");
|
|
|
|
// type vector is the same for drdd functions
|
|
vector<FunctionDataList::FuncDataListType> types;
|
|
types.push_back(FunctionDataList::DOUBLE_LISTTYPE);
|
|
types.push_back(FunctionDataList::DOUBLE_LISTTYPE);
|
|
types.push_back(FunctionDataList::DOUBLE_LISTTYPE);
|
|
|
|
int numRows = 1;
|
|
DoubleElementType el0, el1, el2;
|
|
list<string>::iterator it;
|
|
|
|
for (it = functionsToTest.begin(); it != functionsToTest.end(); it++)
|
|
{
|
|
FunctionOperation::Function_t* fp = fop->getFunctionObjPtr(*it, types);
|
|
CPPUNIT_ASSERT(fp);
|
|
WSDL<DoubleElementType>* wsdlOut = new WSDL<DoubleElementType>(1, numRows, fRm);
|
|
WSDL<DoubleElementType>* wsdlIn1 = new WSDL<DoubleElementType>(2, numRows, fRm);
|
|
WSDL<DoubleElementType>* wsdlIn2 = new WSDL<DoubleElementType>(2, numRows, fRm);
|
|
|
|
for (int i = 0; i < numRows; i++)
|
|
{
|
|
el1.first = i;
|
|
el1.second = (0.5);
|
|
wsdlIn1->insert(el1);
|
|
wsdlIn2->insert(el1); // the data in two list is the same
|
|
}
|
|
|
|
wsdlIn1->endOfInput();
|
|
wsdlIn2->endOfInput();
|
|
|
|
FunctionDataListSPtr listOut(new FunctionDataList());
|
|
FunctionDataListSPtr listIn1(new FunctionDataList());
|
|
FunctionDataListSPtr listIn2(new FunctionDataList());
|
|
FDLVec parms;
|
|
listOut->doubleDl(wsdlOut);
|
|
listIn1->doubleDl(wsdlIn1);
|
|
listIn2->doubleDl(wsdlIn2);
|
|
parms.push_back(listOut);
|
|
parms.push_back(listIn1);
|
|
parms.push_back(listIn2);
|
|
fop->executeFunction(fop, fp, parms);
|
|
wsdlOut->endOfInput();
|
|
|
|
int id0 = wsdlOut->getIterator();
|
|
int id1 = wsdlIn1->getIterator();
|
|
int id2 = wsdlIn2->getIterator();
|
|
|
|
for (int i = 0; i < numRows; i++)
|
|
{
|
|
wsdlIn1->next(id1, &el1);
|
|
wsdlIn2->next(id2, &el2);
|
|
wsdlOut->next(id0, &el0);
|
|
cout << *it << "(" << el1.second << ", " << el2.second << ")=" << el0.second << endl;
|
|
}
|
|
}
|
|
}
|
|
|
|
void testSrssFunctions()
|
|
{
|
|
cout << endl;
|
|
cout << "string f(string, string) functions" << endl;
|
|
cout << "---------------------------" << endl;
|
|
|
|
FunctionOperation* fop = FunctionOperation::instance();
|
|
|
|
list<string> functionsToTest;
|
|
functionsToTest.push_back("||");
|
|
functionsToTest.push_back("concat");
|
|
|
|
// type vector is the same for drdd functions
|
|
vector<FunctionDataList::FuncDataListType> types;
|
|
types.push_back(FunctionDataList::STRING_LISTTYPE);
|
|
types.push_back(FunctionDataList::STRING_LISTTYPE);
|
|
types.push_back(FunctionDataList::STRING_LISTTYPE);
|
|
|
|
int numRows = 1;
|
|
StringElementType el0, el1, el2;
|
|
list<string>::iterator it;
|
|
|
|
for (it = functionsToTest.begin(); it != functionsToTest.end(); it++)
|
|
{
|
|
FunctionOperation::Function_t* fp = fop->getFunctionObjPtr(*it, types);
|
|
CPPUNIT_ASSERT(fp);
|
|
WSDL<StringElementType>* wsdlOut = new WSDL<StringElementType>(1, numRows, fRm);
|
|
WSDL<StringElementType>* wsdlIn1 = new WSDL<StringElementType>(2, numRows, fRm);
|
|
WSDL<StringElementType>* wsdlIn2 = new WSDL<StringElementType>(2, numRows, fRm);
|
|
|
|
for (int i = 0; i < numRows; i++)
|
|
{
|
|
el1.first = i;
|
|
el1.second = "abc";
|
|
wsdlIn1->insert(el1);
|
|
wsdlIn2->insert(el1); // the data in two list is the same
|
|
}
|
|
|
|
wsdlIn1->endOfInput();
|
|
wsdlIn2->endOfInput();
|
|
|
|
FunctionDataListSPtr listOut(new FunctionDataList());
|
|
FunctionDataListSPtr listIn1(new FunctionDataList());
|
|
FunctionDataListSPtr listIn2(new FunctionDataList());
|
|
FDLVec parms;
|
|
listOut->stringDl(wsdlOut);
|
|
listIn1->stringDl(wsdlIn1);
|
|
listIn2->stringDl(wsdlIn2);
|
|
parms.push_back(listOut);
|
|
parms.push_back(listIn1);
|
|
parms.push_back(listIn2);
|
|
fop->executeFunction(fop, fp, parms);
|
|
wsdlOut->endOfInput();
|
|
|
|
int id0 = wsdlOut->getIterator();
|
|
int id1 = wsdlIn1->getIterator();
|
|
int id2 = wsdlIn2->getIterator();
|
|
|
|
for (int i = 0; i < numRows; i++)
|
|
{
|
|
wsdlIn1->next(id1, &el1);
|
|
wsdlIn2->next(id2, &el2);
|
|
wsdlOut->next(id0, &el0);
|
|
cout << *it << "(" << el1.second << ", " << el2.second << ")=" << el0.second << endl;
|
|
}
|
|
}
|
|
}
|
|
|
|
void testSrsFunctions()
|
|
{
|
|
cout << endl;
|
|
cout << "string f(string) functions" << endl;
|
|
cout << "---------------------------" << endl;
|
|
|
|
FunctionOperation* fop = FunctionOperation::instance();
|
|
|
|
list<string> functionsToTest;
|
|
functionsToTest.push_back("upper");
|
|
functionsToTest.push_back("asciistr");
|
|
functionsToTest.push_back("trim");
|
|
functionsToTest.push_back("ltrim");
|
|
functionsToTest.push_back("rtrim");
|
|
|
|
// type vector is the same for drdd functions
|
|
vector<FunctionDataList::FuncDataListType> types;
|
|
types.push_back(FunctionDataList::STRING_LISTTYPE);
|
|
types.push_back(FunctionDataList::STRING_LISTTYPE);
|
|
|
|
int numRows = 2;
|
|
StringElementType el0, el1, el2;
|
|
list<string>::iterator it;
|
|
|
|
for (it = functionsToTest.begin(); it != functionsToTest.end(); it++)
|
|
{
|
|
FunctionOperation::Function_t* fp = fop->getFunctionObjPtr(*it, types);
|
|
CPPUNIT_ASSERT(fp);
|
|
WSDL<StringElementType>* wsdlOut = new WSDL<StringElementType>(1, numRows, fRm);
|
|
WSDL<StringElementType>* wsdlIn1 = new WSDL<StringElementType>(2, numRows, fRm);
|
|
|
|
char abc[][10] = {" abc ", "second"};
|
|
abc[0][3] = 222; // 0xDE
|
|
|
|
for (int i = 0; i < numRows; i++)
|
|
{
|
|
el1.first = i;
|
|
el1.second = abc[i];
|
|
wsdlIn1->insert(el1);
|
|
}
|
|
|
|
wsdlIn1->endOfInput();
|
|
|
|
FunctionDataListSPtr listOut(new FunctionDataList());
|
|
FunctionDataListSPtr listIn1(new FunctionDataList());
|
|
FDLVec parms;
|
|
listOut->stringDl(wsdlOut);
|
|
listIn1->stringDl(wsdlIn1);
|
|
parms.push_back(listOut);
|
|
parms.push_back(listIn1);
|
|
fop->executeFunction(fop, fp, parms);
|
|
wsdlOut->endOfInput();
|
|
|
|
int id0 = wsdlOut->getIterator();
|
|
int id1 = wsdlIn1->getIterator();
|
|
|
|
for (int i = 0; i < numRows; i++)
|
|
{
|
|
wsdlIn1->next(id1, &el1);
|
|
wsdlOut->next(id0, &el0);
|
|
cout << *it << "(\'" << el1.second << "\')="
|
|
<< "\'" << el0.second << "\'" << endl;
|
|
}
|
|
}
|
|
}
|
|
|
|
void testAddFunctions()
|
|
{
|
|
cout << endl;
|
|
cout << "add(<S>, <T>) functions" << endl;
|
|
cout << "---------------------------" << endl;
|
|
|
|
FunctionOperation* fop = FunctionOperation::instance();
|
|
|
|
// the map only have one entry for add_ddd, which is mapped to add(any)
|
|
vector<FunctionDataList::FuncDataListType> types;
|
|
types.push_back(FunctionDataList::DOUBLE_LISTTYPE);
|
|
types.push_back(FunctionDataList::DOUBLE_LISTTYPE);
|
|
types.push_back(FunctionDataList::DOUBLE_LISTTYPE);
|
|
|
|
int numRows = 1;
|
|
|
|
// double list
|
|
WSDL<DoubleElementType>* wsdlInD1 = new WSDL<DoubleElementType>(20, numRows, fRm);
|
|
WSDL<DoubleElementType>* wsdlInD2 = new WSDL<DoubleElementType>(20, numRows, fRm);
|
|
// uint32_t list
|
|
WSDL<ElementType>* wsdlInU1 = new WSDL<ElementType>(20, numRows, fRm);
|
|
WSDL<ElementType>* wsdlInU2 = new WSDL<ElementType>(20, numRows, fRm);
|
|
// string list
|
|
WSDL<StringElementType>* wsdlInS1 = new WSDL<StringElementType>(20, numRows, fRm);
|
|
WSDL<StringElementType>* wsdlInS2 = new WSDL<StringElementType>(20, numRows, fRm);
|
|
DoubleElementType eld;
|
|
ElementType elu;
|
|
StringElementType els;
|
|
|
|
for (int i = 0; i < numRows; i++)
|
|
{
|
|
eld.first = i;
|
|
eld.second = (0.5);
|
|
wsdlInD1->insert(eld);
|
|
wsdlInD2->insert(eld);
|
|
elu.first = i;
|
|
elu.second = (6);
|
|
wsdlInU1->insert(elu);
|
|
wsdlInU2->insert(elu);
|
|
els.first = i;
|
|
els.second = "8.8";
|
|
wsdlInS1->insert(els);
|
|
wsdlInS2->insert(els);
|
|
}
|
|
|
|
wsdlInD1->endOfInput();
|
|
wsdlInD2->endOfInput();
|
|
wsdlInU1->endOfInput();
|
|
wsdlInU2->endOfInput();
|
|
wsdlInS1->endOfInput();
|
|
wsdlInS2->endOfInput();
|
|
|
|
// double add(double, double)
|
|
{
|
|
DoubleElementType el0, el1, el2;
|
|
FunctionOperation::Function_t* fp = fop->getFunctionObjPtr("+", types);
|
|
CPPUNIT_ASSERT(fp);
|
|
WSDL<DoubleElementType>* wsdlOut = new WSDL<DoubleElementType>(1, numRows, fRm);
|
|
|
|
FunctionDataListSPtr listOut(new FunctionDataList());
|
|
FunctionDataListSPtr listIn1(new FunctionDataList());
|
|
FunctionDataListSPtr listIn2(new FunctionDataList());
|
|
FDLVec parms;
|
|
listOut->doubleDl(wsdlOut);
|
|
listIn1->doubleDl(wsdlInD1);
|
|
listIn2->doubleDl(wsdlInD2);
|
|
parms.push_back(listOut);
|
|
parms.push_back(listIn1);
|
|
parms.push_back(listIn2);
|
|
fop->executeFunction(fop, fp, parms);
|
|
wsdlOut->endOfInput();
|
|
|
|
int id0 = wsdlOut->getIterator();
|
|
int id1 = wsdlInD1->getIterator();
|
|
int id2 = wsdlInD2->getIterator();
|
|
|
|
for (int i = 0; i < numRows; i++)
|
|
{
|
|
wsdlInD1->next(id1, &el1);
|
|
wsdlInD2->next(id2, &el2);
|
|
wsdlOut->next(id0, &el0);
|
|
cout << "+"
|
|
<< "(" << el1.second << ", " << el2.second << ")=" << el0.second << endl;
|
|
}
|
|
}
|
|
|
|
// double add(double, uint32_t)
|
|
{
|
|
DoubleElementType el0, el1;
|
|
ElementType el2;
|
|
FunctionOperation::Function_t* fp = fop->getFunctionObjPtr("+", types);
|
|
CPPUNIT_ASSERT(fp);
|
|
WSDL<DoubleElementType>* wsdlOut = new WSDL<DoubleElementType>(1, numRows, fRm);
|
|
|
|
FunctionDataListSPtr listOut(new FunctionDataList());
|
|
FunctionDataListSPtr listIn1(new FunctionDataList());
|
|
FunctionDataListSPtr listIn2(new FunctionDataList());
|
|
FDLVec parms;
|
|
listOut->doubleDl(wsdlOut);
|
|
listIn1->doubleDl(wsdlInD1);
|
|
listIn2->uint64Dl(wsdlInU2);
|
|
parms.push_back(listOut);
|
|
parms.push_back(listIn1);
|
|
parms.push_back(listIn2);
|
|
fop->executeFunction(fop, fp, parms);
|
|
wsdlOut->endOfInput();
|
|
|
|
int id0 = wsdlOut->getIterator();
|
|
int id1 = wsdlInD1->getIterator();
|
|
int id2 = wsdlInU2->getIterator();
|
|
|
|
for (int i = 0; i < numRows; i++)
|
|
{
|
|
wsdlInD1->next(id1, &el1);
|
|
wsdlInU2->next(id2, &el2);
|
|
wsdlOut->next(id0, &el0);
|
|
cout << "+"
|
|
<< "(" << el1.second << ", " << el2.second << ")=" << el0.second << endl;
|
|
}
|
|
}
|
|
|
|
// double add(double, string)
|
|
{
|
|
DoubleElementType el0, el1;
|
|
StringElementType el2;
|
|
FunctionOperation::Function_t* fp = fop->getFunctionObjPtr("+", types);
|
|
CPPUNIT_ASSERT(fp);
|
|
WSDL<DoubleElementType>* wsdlOut = new WSDL<DoubleElementType>(1, numRows, fRm);
|
|
|
|
FunctionDataListSPtr listOut(new FunctionDataList());
|
|
FunctionDataListSPtr listIn1(new FunctionDataList());
|
|
FunctionDataListSPtr listIn2(new FunctionDataList());
|
|
FDLVec parms;
|
|
listOut->doubleDl(wsdlOut);
|
|
listIn1->doubleDl(wsdlInD1);
|
|
listIn2->stringDl(wsdlInS2);
|
|
parms.push_back(listOut);
|
|
parms.push_back(listIn1);
|
|
parms.push_back(listIn2);
|
|
fop->executeFunction(fop, fp, parms);
|
|
wsdlOut->endOfInput();
|
|
|
|
int id0 = wsdlOut->getIterator();
|
|
int id1 = wsdlInD1->getIterator();
|
|
int id2 = wsdlInS2->getIterator();
|
|
|
|
for (int i = 0; i < numRows; i++)
|
|
{
|
|
wsdlInD1->next(id1, &el1);
|
|
wsdlInS2->next(id2, &el2);
|
|
wsdlOut->next(id0, &el0);
|
|
cout << "+"
|
|
<< "(" << el1.second << ", " << el2.second << ")=" << el0.second << endl;
|
|
}
|
|
}
|
|
|
|
// double add(uint32_t, double)
|
|
{
|
|
DoubleElementType el0, el2;
|
|
ElementType el1;
|
|
FunctionOperation::Function_t* fp = fop->getFunctionObjPtr("+", types);
|
|
CPPUNIT_ASSERT(fp);
|
|
WSDL<DoubleElementType>* wsdlOut = new WSDL<DoubleElementType>(1, numRows, fRm);
|
|
|
|
FunctionDataListSPtr listOut(new FunctionDataList());
|
|
FunctionDataListSPtr listIn1(new FunctionDataList());
|
|
FunctionDataListSPtr listIn2(new FunctionDataList());
|
|
FDLVec parms;
|
|
listOut->doubleDl(wsdlOut);
|
|
listIn1->uint64Dl(wsdlInU1);
|
|
listIn2->doubleDl(wsdlInD2);
|
|
parms.push_back(listOut);
|
|
parms.push_back(listIn1);
|
|
parms.push_back(listIn2);
|
|
fop->executeFunction(fop, fp, parms);
|
|
wsdlOut->endOfInput();
|
|
|
|
int id0 = wsdlOut->getIterator();
|
|
int id1 = wsdlInU1->getIterator();
|
|
int id2 = wsdlInD2->getIterator();
|
|
|
|
for (int i = 0; i < numRows; i++)
|
|
{
|
|
wsdlInU1->next(id1, &el1);
|
|
wsdlInD2->next(id2, &el2);
|
|
wsdlOut->next(id0, &el0);
|
|
cout << "+"
|
|
<< "(" << el1.second << ", " << el2.second << ")=" << el0.second << endl;
|
|
}
|
|
}
|
|
|
|
// double add(uint32_t, uint32_t)
|
|
{
|
|
DoubleElementType el0;
|
|
ElementType el1, el2;
|
|
FunctionOperation::Function_t* fp = fop->getFunctionObjPtr("+", types);
|
|
CPPUNIT_ASSERT(fp);
|
|
WSDL<DoubleElementType>* wsdlOut = new WSDL<DoubleElementType>(1, numRows, fRm);
|
|
|
|
FunctionDataListSPtr listOut(new FunctionDataList());
|
|
FunctionDataListSPtr listIn1(new FunctionDataList());
|
|
FunctionDataListSPtr listIn2(new FunctionDataList());
|
|
FDLVec parms;
|
|
listOut->doubleDl(wsdlOut);
|
|
listIn1->uint64Dl(wsdlInU1);
|
|
listIn2->uint64Dl(wsdlInU2);
|
|
parms.push_back(listOut);
|
|
parms.push_back(listIn1);
|
|
parms.push_back(listIn2);
|
|
fop->executeFunction(fop, fp, parms);
|
|
wsdlOut->endOfInput();
|
|
|
|
int id0 = wsdlOut->getIterator();
|
|
int id1 = wsdlInU1->getIterator();
|
|
int id2 = wsdlInU2->getIterator();
|
|
|
|
for (int i = 0; i < numRows; i++)
|
|
{
|
|
wsdlInU1->next(id1, &el1);
|
|
wsdlInU2->next(id2, &el2);
|
|
wsdlOut->next(id0, &el0);
|
|
cout << "+"
|
|
<< "(" << el1.second << ", " << el2.second << ")=" << el0.second << endl;
|
|
}
|
|
}
|
|
|
|
// double add(uint32_t, string)
|
|
{
|
|
DoubleElementType el0;
|
|
ElementType el1;
|
|
StringElementType el2;
|
|
FunctionOperation::Function_t* fp = fop->getFunctionObjPtr("+", types);
|
|
CPPUNIT_ASSERT(fp);
|
|
WSDL<DoubleElementType>* wsdlOut = new WSDL<DoubleElementType>(1, numRows, fRm);
|
|
|
|
FunctionDataListSPtr listOut(new FunctionDataList());
|
|
FunctionDataListSPtr listIn1(new FunctionDataList());
|
|
FunctionDataListSPtr listIn2(new FunctionDataList());
|
|
FDLVec parms;
|
|
listOut->doubleDl(wsdlOut);
|
|
listIn1->uint64Dl(wsdlInU1);
|
|
listIn2->stringDl(wsdlInS2);
|
|
parms.push_back(listOut);
|
|
parms.push_back(listIn1);
|
|
parms.push_back(listIn2);
|
|
fop->executeFunction(fop, fp, parms);
|
|
wsdlOut->endOfInput();
|
|
|
|
int id0 = wsdlOut->getIterator();
|
|
int id1 = wsdlInU1->getIterator();
|
|
int id2 = wsdlInS2->getIterator();
|
|
|
|
for (int i = 0; i < numRows; i++)
|
|
{
|
|
wsdlInU1->next(id1, &el1);
|
|
wsdlInS2->next(id2, &el2);
|
|
wsdlOut->next(id0, &el0);
|
|
cout << "+"
|
|
<< "(" << el1.second << ", " << el2.second << ")=" << el0.second << endl;
|
|
}
|
|
}
|
|
|
|
// double add(string, double)
|
|
{
|
|
DoubleElementType el0, el2;
|
|
StringElementType el1;
|
|
FunctionOperation::Function_t* fp = fop->getFunctionObjPtr("+", types);
|
|
CPPUNIT_ASSERT(fp);
|
|
WSDL<DoubleElementType>* wsdlOut = new WSDL<DoubleElementType>(1, numRows, fRm);
|
|
|
|
FunctionDataListSPtr listOut(new FunctionDataList());
|
|
FunctionDataListSPtr listIn1(new FunctionDataList());
|
|
FunctionDataListSPtr listIn2(new FunctionDataList());
|
|
FDLVec parms;
|
|
listOut->doubleDl(wsdlOut);
|
|
listIn1->stringDl(wsdlInS1);
|
|
listIn2->doubleDl(wsdlInD2);
|
|
parms.push_back(listOut);
|
|
parms.push_back(listIn1);
|
|
parms.push_back(listIn2);
|
|
fop->executeFunction(fop, fp, parms);
|
|
wsdlOut->endOfInput();
|
|
|
|
int id0 = wsdlOut->getIterator();
|
|
int id1 = wsdlInS1->getIterator();
|
|
int id2 = wsdlInD2->getIterator();
|
|
|
|
for (int i = 0; i < numRows; i++)
|
|
{
|
|
wsdlInS1->next(id1, &el1);
|
|
wsdlInD2->next(id2, &el2);
|
|
wsdlOut->next(id0, &el0);
|
|
cout << "+"
|
|
<< "(" << el1.second << ", " << el2.second << ")=" << el0.second << endl;
|
|
}
|
|
}
|
|
|
|
// double add(string, uint32_t)
|
|
{
|
|
DoubleElementType el0;
|
|
StringElementType el1;
|
|
ElementType el2;
|
|
FunctionOperation::Function_t* fp = fop->getFunctionObjPtr("+", types);
|
|
CPPUNIT_ASSERT(fp);
|
|
WSDL<DoubleElementType>* wsdlOut = new WSDL<DoubleElementType>(1, numRows, fRm);
|
|
|
|
FunctionDataListSPtr listOut(new FunctionDataList());
|
|
FunctionDataListSPtr listIn1(new FunctionDataList());
|
|
FunctionDataListSPtr listIn2(new FunctionDataList());
|
|
FDLVec parms;
|
|
listOut->doubleDl(wsdlOut);
|
|
listIn1->stringDl(wsdlInS1);
|
|
listIn2->uint64Dl(wsdlInU2);
|
|
parms.push_back(listOut);
|
|
parms.push_back(listIn1);
|
|
parms.push_back(listIn2);
|
|
fop->executeFunction(fop, fp, parms);
|
|
wsdlOut->endOfInput();
|
|
|
|
int id0 = wsdlOut->getIterator();
|
|
int id1 = wsdlInS1->getIterator();
|
|
int id2 = wsdlInU2->getIterator();
|
|
|
|
for (int i = 0; i < numRows; i++)
|
|
{
|
|
wsdlInS1->next(id1, &el1);
|
|
wsdlInU2->next(id2, &el2);
|
|
wsdlOut->next(id0, &el0);
|
|
cout << "+"
|
|
<< "(" << el1.second << ", " << el2.second << ")=" << el0.second << endl;
|
|
}
|
|
}
|
|
|
|
// double add(string, string)
|
|
{
|
|
DoubleElementType el0;
|
|
StringElementType el1, el2;
|
|
FunctionOperation::Function_t* fp = fop->getFunctionObjPtr("+", types);
|
|
CPPUNIT_ASSERT(fp);
|
|
WSDL<DoubleElementType>* wsdlOut = new WSDL<DoubleElementType>(1, numRows, fRm);
|
|
|
|
FunctionDataListSPtr listOut(new FunctionDataList());
|
|
FunctionDataListSPtr listIn1(new FunctionDataList());
|
|
FunctionDataListSPtr listIn2(new FunctionDataList());
|
|
FDLVec parms;
|
|
listOut->doubleDl(wsdlOut);
|
|
listIn1->stringDl(wsdlInS1);
|
|
listIn2->stringDl(wsdlInS2);
|
|
parms.push_back(listOut);
|
|
parms.push_back(listIn1);
|
|
parms.push_back(listIn2);
|
|
fop->executeFunction(fop, fp, parms);
|
|
wsdlOut->endOfInput();
|
|
|
|
int id0 = wsdlOut->getIterator();
|
|
int id1 = wsdlInS1->getIterator();
|
|
int id2 = wsdlInS2->getIterator();
|
|
|
|
for (int i = 0; i < numRows; i++)
|
|
{
|
|
wsdlInS1->next(id1, &el1);
|
|
wsdlInS2->next(id2, &el2);
|
|
wsdlOut->next(id0, &el0);
|
|
cout << "+"
|
|
<< "(" << el1.second << ", " << el2.second << ")=" << el0.second << endl;
|
|
}
|
|
}
|
|
}
|
|
|
|
struct dateTime
|
|
{
|
|
unsigned msecond : 20;
|
|
unsigned second : 6;
|
|
unsigned minute : 6;
|
|
unsigned hour : 6;
|
|
unsigned day : 6;
|
|
unsigned month : 4;
|
|
unsigned year : 16;
|
|
|
|
dateTime(int y = 0xFFFF, int mn = 0xF, int d = 0x3F, int h = 0x3F, int mi = 0x3F, int s = 0x3F,
|
|
int ms = 0xFFFFE)
|
|
{
|
|
year = y;
|
|
month = mn;
|
|
day = d;
|
|
hour = h;
|
|
minute = mi;
|
|
second = s;
|
|
msecond = ms;
|
|
}
|
|
};
|
|
|
|
void testDateFunctions()
|
|
{
|
|
cout << endl;
|
|
cout << "to_date function with formats" << endl;
|
|
cout << "-----------------------------" << endl;
|
|
|
|
FunctionOperation* fop = FunctionOperation::instance();
|
|
|
|
vector<FunctionDataList::FuncDataListType> types;
|
|
types.push_back(FunctionDataList::STRING_LISTTYPE);
|
|
types.push_back(FunctionDataList::UINT64_LISTTYPE);
|
|
types.push_back(FunctionDataList::STRING_CONST_LISTTYPE);
|
|
|
|
// data list
|
|
AnyDataListSPtr spdl1(new AnyDataList());
|
|
BandedDataList* dl1 = new BandedDataList(20, fRm);
|
|
spdl1->bandedDL(dl1);
|
|
|
|
dateTime dt(2007, 11, 12, 16, 7, 8, 999);
|
|
uint64_t idt = *(reinterpret_cast<uint64_t*>(&dt));
|
|
ElementType elu(0, idt);
|
|
|
|
int numRows = 1;
|
|
|
|
for (int i = 0; i < numRows; i++)
|
|
{
|
|
elu.first = i;
|
|
dl1->insert(elu);
|
|
}
|
|
|
|
dl1->endOfInput();
|
|
|
|
char fmt[6][30] = {"YYYYMMDDHH", "YYYYMMDDHHMISS", "YYYYMMDDHHMISSFF",
|
|
"YYYY-MM-DD HH:MI:SS", "MON DD, RRRR", "MM/DD/YY HH24:MI:SS.FF"};
|
|
|
|
for (int i = 0; i < 6; i++)
|
|
{
|
|
AnyDataListSPtr spdl2(new AnyDataList());
|
|
StringElementType els(0, fmt[i]);
|
|
ConstantDataList<StringElementType>* dl2 = new ConstantDataList<StringElementType>(els);
|
|
spdl2->stringConstantDL(dl2);
|
|
dl2->endOfInput();
|
|
|
|
JobStepAssociation inJs;
|
|
inJs.outAdd(spdl1);
|
|
inJs.outAdd(spdl2);
|
|
// jobstep->outputAssociation(outJs); // output of a job step
|
|
|
|
AnyDataListSPtr spdlOut(new AnyDataList());
|
|
StringDataList* dlOut = new StringDataList(1, fRm);
|
|
spdlOut->strDataList(dlOut);
|
|
JobStepAssociation outJs;
|
|
outJs.outAdd(spdlOut);
|
|
// funJobstep->inputAssociation(inJs);
|
|
// funJobstep->outputAssociation(outJs);
|
|
|
|
FunctionOperation::Function_t* fp = fop->getFunctionObjPtr("to_char", types);
|
|
CPPUNIT_ASSERT(fp);
|
|
|
|
FunctionDataListSPtr listOut(new FunctionDataList());
|
|
FunctionDataListSPtr listIn1(new FunctionDataList());
|
|
FunctionDataListSPtr listIn2(new FunctionDataList());
|
|
FDLVec parms;
|
|
listOut->stringDl(outJs.outAt(0)->stringDataList());
|
|
listIn1->uint64Dl(inJs.outAt(0)->dataList());
|
|
listIn2->stringDl(inJs.outAt(1)->stringDataList());
|
|
parms.push_back(listOut);
|
|
parms.push_back(listIn1);
|
|
parms.push_back(listIn2);
|
|
fop->executeFunction(fop, fp, parms);
|
|
dlOut->endOfInput();
|
|
|
|
int id0 = dlOut->getIterator();
|
|
int id1 = dl1->getIterator();
|
|
int id2 = dl2->getIterator();
|
|
StringElementType el0;
|
|
ElementType el1;
|
|
StringElementType el2;
|
|
|
|
for (int i = 0; i < numRows; i++)
|
|
{
|
|
dl1->next(id1, &el1);
|
|
dl2->next(id2, &el2);
|
|
dlOut->next(id0, &el0);
|
|
cout << "to_char"
|
|
<< "(" << el1.second << ", \'" << el2.second << "\')=" << el0.second << endl;
|
|
}
|
|
}
|
|
|
|
// default format
|
|
{
|
|
JobStepAssociation inJs;
|
|
inJs.outAdd(spdl1);
|
|
// jobstep->outputAssociation(outJs); // output of a job step
|
|
|
|
AnyDataListSPtr spdlOut(new AnyDataList());
|
|
StringDataList* dlOut = new StringDataList(1, fRm);
|
|
spdlOut->strDataList(dlOut);
|
|
JobStepAssociation outJs;
|
|
outJs.outAdd(spdlOut);
|
|
// funJobstep->inputAssociation(inJs);
|
|
// funJobstep->outputAssociation(outJs);
|
|
|
|
FunctionOperation::Function_t* fp = fop->getFunctionObjPtr("to_char", types);
|
|
CPPUNIT_ASSERT(fp);
|
|
|
|
FunctionDataListSPtr listOut(new FunctionDataList());
|
|
FunctionDataListSPtr listIn1(new FunctionDataList());
|
|
FDLVec parms;
|
|
listOut->stringDl(outJs.outAt(0)->stringDataList());
|
|
listIn1->uint64Dl(inJs.outAt(0)->dataList());
|
|
parms.push_back(listOut);
|
|
parms.push_back(listIn1);
|
|
fop->executeFunction(fop, fp, parms);
|
|
dlOut->endOfInput();
|
|
|
|
int id0 = dlOut->getIterator();
|
|
int id1 = dl1->getIterator();
|
|
StringElementType el0;
|
|
ElementType el1;
|
|
|
|
for (int i = 0; i < numRows; i++)
|
|
{
|
|
dl1->next(id1, &el1);
|
|
dlOut->next(id0, &el0);
|
|
cout << "to_char"
|
|
<< "(" << el1.second << ")=" << el0.second << endl;
|
|
}
|
|
}
|
|
}
|
|
|
|
void testToNumFunctions()
|
|
{
|
|
cout << endl;
|
|
cout << "to_num function, format ignored" << endl;
|
|
cout << "-------------------------------" << endl;
|
|
|
|
FunctionOperation* fop = FunctionOperation::instance();
|
|
|
|
vector<FunctionDataList::FuncDataListType> types;
|
|
types.push_back(FunctionDataList::DOUBLE_LISTTYPE);
|
|
types.push_back(FunctionDataList::STRING_LISTTYPE);
|
|
types.push_back(FunctionDataList::STRING_CONST_LISTTYPE);
|
|
|
|
AnyDataListSPtr spdl1(new AnyDataList());
|
|
StringFifoDataList* dl1 = new StringFifoDataList(2, 100);
|
|
spdl1->stringDL(dl1);
|
|
|
|
const int numRows = 6;
|
|
char num[numRows][30] = {"2007111218", "1234567.8", "-123456.78", "2,007,111,218", "1.23E3", "-1.23E-3"};
|
|
|
|
StringRowGroup rows;
|
|
|
|
for (int i = 0; i < numRows; i++)
|
|
{
|
|
StringElementType els(0, num[i]);
|
|
rows.et[rows.count++] = els;
|
|
// dl1->insert(els);
|
|
}
|
|
|
|
dl1->insert(rows);
|
|
dl1->endOfInput();
|
|
|
|
// format model, ignored
|
|
AnyDataListSPtr spdl2(new AnyDataList());
|
|
StringElementType els(0, "dummy");
|
|
ConstantDataList<StringElementType>* dl2 = new ConstantDataList<StringElementType>(els);
|
|
spdl2->stringConstantDL(dl2);
|
|
dl2->endOfInput();
|
|
|
|
JobStepAssociation inJs;
|
|
inJs.outAdd(spdl1);
|
|
inJs.outAdd(spdl2);
|
|
// jobstep->outputAssociation(outJs); // output of a job step
|
|
|
|
AnyDataListSPtr spdlOut(new AnyDataList());
|
|
FIFO<DoubleElementType>* dlOut = new FIFO<DoubleElementType>(1, 100);
|
|
spdlOut->doubleDL(dlOut);
|
|
JobStepAssociation outJs;
|
|
outJs.outAdd(spdlOut);
|
|
// funJobstep->inputAssociation(inJs);
|
|
// funJobstep->outputAssociation(outJs);
|
|
|
|
FunctionOperation::Function_t* fp = fop->getFunctionObjPtr("to_number", types);
|
|
CPPUNIT_ASSERT(fp);
|
|
|
|
FunctionDataListSPtr listOut(new FunctionDataList());
|
|
FunctionDataListSPtr listIn1(new FunctionDataList());
|
|
FunctionDataListSPtr listIn2(new FunctionDataList());
|
|
FDLVec parms;
|
|
listOut->doubleDl(outJs.outAt(0)->doubleDL());
|
|
listIn1->stringDl(inJs.outAt(0)->stringDataList());
|
|
listIn2->stringDl(inJs.outAt(1)->stringDataList());
|
|
parms.push_back(listOut);
|
|
parms.push_back(listIn1);
|
|
parms.push_back(listIn2);
|
|
fop->executeFunction(fop, fp, parms);
|
|
dlOut->endOfInput();
|
|
|
|
int id1 = dl1->getIterator();
|
|
int id2 = dl2->getIterator();
|
|
int id0 = dlOut->getIterator();
|
|
// StringElementType el1;
|
|
StringRowGroup el1;
|
|
StringElementType el2;
|
|
DoubleElementType el0;
|
|
|
|
for (int i = 0; i < numRows; i++)
|
|
{
|
|
dl1->next(id1, &el1);
|
|
dl2->next(id2, &el2);
|
|
dlOut->next(id0, &el0);
|
|
cout << "to_number"
|
|
<< "(\'" << el1.et[i].second << "\', \'" << el2.second << "\')=" << setw(20) << setprecision(10)
|
|
<< el0.second << endl;
|
|
}
|
|
}
|
|
|
|
/*
|
|
void testDrdFunctions()
|
|
{
|
|
cout << endl;
|
|
cout << "double f(double) functions" << endl;
|
|
cout << "---------------------------" << endl;
|
|
FunctionOperation fo;
|
|
drdMap_t::iterator it;
|
|
drdMap_t map = fo.getDrdMap();
|
|
int numRows = 1;
|
|
DoubleElementType el, el2;
|
|
for(it = map.begin(); it!= map.end(); it++)
|
|
{
|
|
CPPUNIT_ASSERT(fo.isDrdFunction(it->first));
|
|
WSDL<DoubleElementType> wsdlIn(2, numRows);
|
|
WSDL<DoubleElementType> wsdlOut(1, numRows);
|
|
for(int i = 0; i < numRows; i++) {
|
|
el.first = i;
|
|
el.second = (0.5);
|
|
wsdlIn.insert(el);
|
|
}
|
|
wsdlIn.endOfInput();
|
|
fo.executeDrdFunction(it->first, wsdlIn, wsdlOut);
|
|
wsdlOut.endOfInput();
|
|
int id = wsdlIn.getIterator();
|
|
int id2 = wsdlOut.getIterator();
|
|
for(int i = 0; i < numRows; i++) {
|
|
wsdlIn.next(id, &el);
|
|
wsdlOut.next(id2, &el2);
|
|
cout << it->first << "(" << el.second << ")=" << el2.second << endl;
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
void testDrddFunctions()
|
|
{
|
|
cout << endl;
|
|
cout << "double f(double, double) functions" << endl;
|
|
cout << "---------------------------" << endl;
|
|
FunctionOperation fo;
|
|
drddMap_t::iterator it;
|
|
drddMap_t map = fo.getDrddMap();
|
|
int numRows = 1;
|
|
DoubleElementType el, el2, el3;
|
|
for(it = map.begin(); it!= map.end(); it++)
|
|
{
|
|
CPPUNIT_ASSERT(fo.isDrddFunction(it->first));
|
|
WSDL<DoubleElementType> wsdlIn(2, numRows);
|
|
WSDL<DoubleElementType> wsdlIn2(2, numRows);
|
|
WSDL<DoubleElementType> wsdlOut(1, numRows);
|
|
for(int i = 0; i < numRows; i++) {
|
|
el.first = i;
|
|
el.second = (0.5);
|
|
wsdlIn.insert(el);
|
|
wsdlIn2.insert(el);
|
|
}
|
|
wsdlIn.endOfInput();
|
|
wsdlIn2.endOfInput();
|
|
fo.executeDrddFunction(it->first, wsdlIn, wsdlIn2, wsdlOut);
|
|
wsdlOut.endOfInput();
|
|
int id = wsdlIn.getIterator();
|
|
int id2 = wsdlIn2.getIterator();
|
|
int id3 = wsdlOut.getIterator();
|
|
for(int i = 0; i < numRows; i++) {
|
|
wsdlIn.next(id, &el);
|
|
wsdlIn2.next(id2, &el2);
|
|
wsdlOut.next(id3, &el3);
|
|
cout << it->first << "(" << el.second << ", " << el2.second << ")=" <<
|
|
el3.second << endl;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void testSrssFunctions()
|
|
{
|
|
cout << endl;
|
|
cout << "string f(string, string) functions" << endl;
|
|
cout << "---------------------------" << endl;
|
|
FunctionOperation fo;
|
|
srssMap_t::iterator it;
|
|
srssMap_t map = fo.getSrssMap();
|
|
int numRows = 1;
|
|
StringElementType el, el2, el3;
|
|
for(it = map.begin(); it!= map.end(); it++)
|
|
{
|
|
CPPUNIT_ASSERT(fo.isSrssFunction(it->first));
|
|
WSDL<StringElementType> wsdlIn(2, numRows);
|
|
WSDL<StringElementType> wsdlIn2(2, numRows);
|
|
WSDL<StringElementType> wsdlOut(1, numRows);
|
|
for(int i = 0; i < numRows; i++) {
|
|
el.first = i;
|
|
el.second = "abc";
|
|
wsdlIn.insert(el);
|
|
wsdlIn2.insert(el);
|
|
}
|
|
wsdlIn.endOfInput();
|
|
wsdlIn2.endOfInput();
|
|
fo.executeSrssFunction(it->first, wsdlIn, wsdlIn2, wsdlOut);
|
|
wsdlOut.endOfInput();
|
|
int id = wsdlIn.getIterator();
|
|
int id2 = wsdlIn2.getIterator();
|
|
int id3 = wsdlOut.getIterator();
|
|
for(int i = 0; i < numRows; i++) {
|
|
wsdlIn.next(id, &el);
|
|
wsdlIn2.next(id2, &el2);
|
|
wsdlOut.next(id3, &el3);
|
|
cout << it->first << "(" << el.second << ", " << el2.second << ")=" <<
|
|
el3.second << endl;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void testSrsFunctions()
|
|
{
|
|
cout << endl;
|
|
cout << "string f(string) functions" << endl;
|
|
cout << "---------------------------" << endl;
|
|
FunctionOperation fo;
|
|
srsMap_t::iterator it;
|
|
srsMap_t map = fo.getSrsMap();
|
|
int numRows = 2;
|
|
StringElementType elIn, elOut;
|
|
for(it = map.begin(); it!= map.end(); it++)
|
|
{
|
|
CPPUNIT_ASSERT(fo.isSrsFunction(it->first));
|
|
WSDL<StringElementType> wsdlIn(2, numRows);
|
|
WSDL<StringElementType> wsdlOut(1, numRows);
|
|
char abc[][10] = {" abc ", "second"};
|
|
abc[0][3] = 222; // 0xDE
|
|
for(int i = 0; i < numRows; i++) {
|
|
elIn.first = i;
|
|
elIn.second = abc[i];
|
|
wsdlIn.insert(elIn);
|
|
}
|
|
wsdlIn.endOfInput();
|
|
fo.executeSrsFunction(it->first, wsdlIn, wsdlOut);
|
|
wsdlOut.endOfInput();
|
|
int idi = wsdlIn.getIterator();
|
|
int ido = wsdlOut.getIterator();
|
|
for(int i = 0; i < numRows; i++) {
|
|
wsdlIn.next(idi, &elIn);
|
|
wsdlOut.next(ido, &elOut);
|
|
cout << it->first << "(\"" << elIn.second << "\")=" << "\"" << elOut.second << "\"" << endl;
|
|
}
|
|
}
|
|
|
|
}
|
|
*/
|
|
|
|
public:
|
|
void FUNCTION_TEST()
|
|
{
|
|
testDrdFunctions();
|
|
testDrddFunctions();
|
|
testSrssFunctions();
|
|
testSrsFunctions();
|
|
testAddFunctions();
|
|
testDateFunctions();
|
|
testToNumFunctions();
|
|
}
|
|
|
|
// Executes an addition (+ function) between two large DataLists and displays timing results.
|
|
// Asserts that the output DataList contains the correct results.
|
|
void PERFORMANCE_TEST()
|
|
{
|
|
cout << endl << endl;
|
|
cout << "Performance Test" << endl;
|
|
cout << "----------------------------------------------------------------------------------------"
|
|
<< endl;
|
|
Timer timer;
|
|
int numRows = 1000 * 1000 * 2;
|
|
typedef WSDL<DoubleElementType> DoubleWSDL;
|
|
DoubleWSDL* wsdlOut = new DoubleWSDL(1, numRows, fRm);
|
|
DoubleWSDL* wsdlIn1 = new DoubleWSDL(2, numRows, fRm);
|
|
DoubleWSDL* wsdlIn2 = new DoubleWSDL(2, numRows, fRm);
|
|
|
|
stringstream ss;
|
|
ss << "Loading " << numRows << " DoubleElementTypes into a WSDL.";
|
|
string message = ss.str();
|
|
timer.start(message);
|
|
|
|
DoubleElementType el;
|
|
|
|
for (int i = 0; i < numRows; i++)
|
|
{
|
|
el.first = i;
|
|
el.second = (i % 5);
|
|
wsdlIn1->insert(el);
|
|
}
|
|
|
|
wsdlIn1->endOfInput();
|
|
timer.stop(message);
|
|
|
|
stringstream ss2;
|
|
ss2 << "Loading " << numRows << " DoubleElementTypes into a second WSDL.";
|
|
message = ss2.str();
|
|
timer.start(message);
|
|
|
|
for (int i = 0; i < numRows; i++)
|
|
{
|
|
el.first = i;
|
|
el.second = (i % 5);
|
|
wsdlIn2->insert(el);
|
|
}
|
|
|
|
wsdlIn2->endOfInput();
|
|
timer.stop(message);
|
|
|
|
message = "Building FunctionDataList and vector";
|
|
timer.start(message);
|
|
FunctionDataListSPtr listOut(new FunctionDataList());
|
|
FunctionDataListSPtr listIn1(new FunctionDataList());
|
|
FunctionDataListSPtr listIn2(new FunctionDataList());
|
|
FDLVec parms;
|
|
listOut->doubleDl(wsdlOut);
|
|
listIn1->doubleDl(wsdlIn1);
|
|
listIn2->doubleDl(wsdlIn2);
|
|
parms.push_back(listOut);
|
|
parms.push_back(listIn1);
|
|
parms.push_back(listIn2);
|
|
|
|
vector<FunctionDataList::FuncDataListType> types;
|
|
types.push_back(FunctionDataList::DOUBLE_LISTTYPE);
|
|
types.push_back(FunctionDataList::DOUBLE_LISTTYPE);
|
|
types.push_back(FunctionDataList::DOUBLE_LISTTYPE);
|
|
timer.stop(message);
|
|
|
|
message = "Executing addition and loading result into a third WSDL.";
|
|
timer.start(message);
|
|
FunctionOperation* fop = FunctionOperation::instance();
|
|
FunctionOperation::Function_t* fp = fop->getFunctionObjPtr("+", types);
|
|
CPPUNIT_ASSERT(fp);
|
|
fop->executeFunction(fop, fp, parms);
|
|
timer.stop(message);
|
|
wsdlOut->endOfInput();
|
|
|
|
message = "Iterating over results and doing asserts.";
|
|
timer.start(message);
|
|
DoubleElementType el0, el1, el2;
|
|
int id0 = wsdlOut->getIterator();
|
|
int id1 = wsdlIn1->getIterator();
|
|
int id2 = wsdlIn2->getIterator();
|
|
|
|
for (int i = 0; i < numRows; i++)
|
|
{
|
|
wsdlOut->next(id0, &el0);
|
|
wsdlIn1->next(id1, &el1);
|
|
wsdlIn2->next(id2, &el2);
|
|
|
|
CPPUNIT_ASSERT(el0.first == el1.first);
|
|
CPPUNIT_ASSERT(el0.second == (el1.second + el2.second));
|
|
}
|
|
|
|
timer.stop(message);
|
|
}
|
|
/*
|
|
void PERFORMANCE_TEST()
|
|
{
|
|
cout << endl << endl;
|
|
cout << "Performance Test" << endl;
|
|
cout <<
|
|
"----------------------------------------------------------------------------------------" << endl; Timer
|
|
timer; int id; int numRows = 1000 * 1000 * 2; DoubleElementType el, el2, el3; WSDL<DoubleElementType>
|
|
wsdlIn(2, numRows); WSDL<DoubleElementType> wsdlIn2(2, numRows); WSDL<DoubleElementType> wsdlOut(1,
|
|
numRows);
|
|
|
|
stringstream ss;
|
|
ss << "Loading " << numRows << " DoubleElementTypes into a WSDL.";
|
|
string message = ss.str();
|
|
timer.start(message);
|
|
|
|
for(int i = 0; i < numRows; i++) {
|
|
el.first = i;
|
|
el.second = (i%5);
|
|
wsdlIn.insert(el);
|
|
}
|
|
wsdlIn.endOfInput();
|
|
timer.stop(message);
|
|
|
|
stringstream ss2;
|
|
ss2 << "Loading " << numRows << " DoubleElementTypes into a second WSDL.";
|
|
message = ss2.str();
|
|
timer.start(message);
|
|
|
|
for(int i = 0; i < numRows; i++) {
|
|
el.first = i;
|
|
el.second = (i%5);
|
|
wsdlIn2.insert(el);
|
|
}
|
|
wsdlIn2.endOfInput();
|
|
timer.stop(message);
|
|
|
|
message = "Executing addition and loading result into a third WSDL.";
|
|
timer.start(message);
|
|
FunctionOperation fo;
|
|
fo.executeDrddFunction("+", wsdlIn, wsdlIn2, wsdlOut);
|
|
timer.stop(message);
|
|
wsdlOut.endOfInput();
|
|
|
|
message = "Iterating over results and doing asserts.";
|
|
timer.start(message);
|
|
id = wsdlIn.getIterator();
|
|
int id2 = wsdlIn2.getIterator();
|
|
int id3 = wsdlOut.getIterator();
|
|
for(int i = 0; i < numRows; i++) {
|
|
wsdlIn.next(id, &el);
|
|
wsdlIn2.next(id2, &el2);
|
|
wsdlOut.next(id3, &el3);
|
|
|
|
CPPUNIT_ASSERT(el.first == el3.first);
|
|
CPPUNIT_ASSERT((el.second + el2.second) == el3.second);
|
|
|
|
}
|
|
timer.stop(message);
|
|
}
|
|
*/
|
|
};
|
|
|
|
CPPUNIT_TEST_SUITE_REGISTRATION(functionDriver);
|
|
|
|
int main(int argc, char** argv)
|
|
{
|
|
CppUnit::TextUi::TestRunner runner;
|
|
CppUnit::TestFactoryRegistry& registry = CppUnit::TestFactoryRegistry::getRegistry();
|
|
runner.addTest(registry.makeTest());
|
|
bool wasSuccessful = runner.run("", false);
|
|
return (wasSuccessful ? 0 : 1);
|
|
}
|