database/mariadb-columnstore-engine
1
0
Fork 0
mirror of https://github.com/mariadb-corporation/mariadb-columnstore-engine.git synced 2025-07-30 19:23:07 +03:00
Code Activity

clang format apply

Browse Source
This commit is contained in:
Leonid Fedorov
2022-01-21 16:43:49 +00:00
parent 6b6411229f
commit 04752ec546
1376 changed files with 393460 additions and 412662 deletions
Download Patch File Download Diff File Expand all files Collapse all files

212
utils/regr/corr.cpp
View File

@ -26,11 +26,11 @@ using namespace mcsv1sdk;
class Add_corr_ToUDAFMap
{
public:
Add_corr_ToUDAFMap()
{
UDAFMap::getMap()["corr"] = new corr();
}
public:
Add_corr_ToUDAFMap()
{
UDAFMap::getMap()["corr"] = new corr();
}
};
static Add_corr_ToUDAFMap addToMap;
@ -38,142 +38,138 @@ static Add_corr_ToUDAFMap addToMap;
// Use the simple data model
struct corr_data
{
uint64_t cnt;
long double sumx;
long double sumx2; // sum of (x squared)
long double sumy;
long double sumy2; // sum of (y squared)
long double sumxy; // sum of x * y
uint64_t cnt;
long double sumx;
long double sumx2; // sum of (x squared)
long double sumy;
long double sumy2; // sum of (y squared)
long double sumxy; // sum of x * y
};
mcsv1_UDAF::ReturnCode corr::init(mcsv1Context* context,
ColumnDatum* colTypes)
mcsv1_UDAF::ReturnCode corr::init(mcsv1Context* context, ColumnDatum* colTypes)
{
if (context->getParameterCount() != 2)
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("corr() with other than 2 arguments");
return mcsv1_UDAF::ERROR;
}
if (!(isNumeric(colTypes[0].dataType) && isNumeric(colTypes[1].dataType)))
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("corr() with non-numeric arguments");
return mcsv1_UDAF::ERROR;
}
context->setUserDataSize(sizeof(corr_data));
context->setResultType(execplan::CalpontSystemCatalog::DOUBLE);
context->setColWidth(8);
context->setScale(DECIMAL_NOT_SPECIFIED);
context->setPrecision(0);
context->setRunFlag(mcsv1sdk::UDAF_IGNORE_NULLS);
return mcsv1_UDAF::SUCCESS;
if (context->getParameterCount() != 2)
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("corr() with other than 2 arguments");
return mcsv1_UDAF::ERROR;
}
if (!(isNumeric(colTypes[0].dataType) && isNumeric(colTypes[1].dataType)))
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("corr() with non-numeric arguments");
return mcsv1_UDAF::ERROR;
}
context->setUserDataSize(sizeof(corr_data));
context->setResultType(execplan::CalpontSystemCatalog::DOUBLE);
context->setColWidth(8);
context->setScale(DECIMAL_NOT_SPECIFIED);
context->setPrecision(0);
context->setRunFlag(mcsv1sdk::UDAF_IGNORE_NULLS);
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode corr::reset(mcsv1Context* context)
{
struct corr_data* data = (struct corr_data*)context->getUserData()->data;
data->cnt = 0;
data->sumx = 0.0;
data->sumx2 = 0.0;
data->sumy = 0.0;
data->sumy2 = 0.0;
data->sumxy = 0.0;
return mcsv1_UDAF::SUCCESS;
struct corr_data* data = (struct corr_data*)context->getUserData()->data;
data->cnt = 0;
data->sumx = 0.0;
data->sumx2 = 0.0;
data->sumy = 0.0;
data->sumy2 = 0.0;
data->sumxy = 0.0;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode corr::nextValue(mcsv1Context* context, ColumnDatum* valsIn)
{
double valy = toDouble(valsIn[0]);
double valx = toDouble(valsIn[1]);
struct corr_data* data = (struct corr_data*)context->getUserData()->data;
double valy = toDouble(valsIn[0]);
double valx = toDouble(valsIn[1]);
struct corr_data* data = (struct corr_data*)context->getUserData()->data;
data->sumy += valy;
data->sumy2 += valy*valy;
data->sumy += valy;
data->sumy2 += valy * valy;
data->sumx += valx;
data->sumx2 += valx*valx;
data->sumx += valx;
data->sumx2 += valx * valx;
data->sumxy += valx*valy;
data->sumxy += valx * valy;
++data->cnt;
return mcsv1_UDAF::SUCCESS;
++data->cnt;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode corr::subEvaluate(mcsv1Context* context, const UserData* userDataIn)
{
if (!userDataIn)
{
return mcsv1_UDAF::SUCCESS;
}
struct corr_data* outData = (struct corr_data*)context->getUserData()->data;
struct corr_data* inData = (struct corr_data*)userDataIn->data;
outData->sumx += inData->sumx;
outData->sumx2 += inData->sumx2;
outData->sumy += inData->sumy;
outData->sumy2 += inData->sumy2;
outData->sumxy += inData->sumxy;
outData->cnt += inData->cnt;
if (!userDataIn)
{
return mcsv1_UDAF::SUCCESS;
}
struct corr_data* outData = (struct corr_data*)context->getUserData()->data;
struct corr_data* inData = (struct corr_data*)userDataIn->data;
outData->sumx += inData->sumx;
outData->sumx2 += inData->sumx2;
outData->sumy += inData->sumy;
outData->sumy2 += inData->sumy2;
outData->sumxy += inData->sumxy;
outData->cnt += inData->cnt;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode corr::evaluate(mcsv1Context* context, static_any::any& valOut)
{
struct corr_data* data = (struct corr_data*)context->getUserData()->data;
double N = data->cnt;
if (N > 1)
{
long double sumx = data->sumx;
long double sumy = data->sumy;
long double sumx2 = data->sumx2;
long double sumy2 = data->sumy2;
long double sumxy = data->sumxy;
struct corr_data* data = (struct corr_data*)context->getUserData()->data;
double N = data->cnt;
if (N > 1)
{
long double sumx = data->sumx;
long double sumy = data->sumy;
long double sumx2 = data->sumx2;
long double sumy2 = data->sumy2;
long double sumxy = data->sumxy;
long double var_popx = (sumx2 - (sumx * sumx / N)) / N;
if (var_popx <= 0) // Catch -0
{
// When var_popx is 0, NULL is the result.
return mcsv1_UDAF::SUCCESS;
}
long double var_popy = (sumy2 - (sumy * sumy / N)) / N;
if (var_popy <= 0) // Catch -0
{
// When var_popy is 0, NULL is the result
return mcsv1_UDAF::SUCCESS;
}
long double std_popx = sqrt(var_popx);
long double std_popy = sqrt(var_popy);
long double covar_pop = (sumxy - ((sumx * sumy) / N)) / N;
long double corr = covar_pop / (std_popy * std_popx);
valOut = static_cast<double>(corr);
long double var_popx = (sumx2 - (sumx * sumx / N)) / N;
if (var_popx <= 0) // Catch -0
{
// When var_popx is 0, NULL is the result.
return mcsv1_UDAF::SUCCESS;
}
return mcsv1_UDAF::SUCCESS;
long double var_popy = (sumy2 - (sumy * sumy / N)) / N;
if (var_popy <= 0) // Catch -0
{
// When var_popy is 0, NULL is the result
return mcsv1_UDAF::SUCCESS;
}
long double std_popx = sqrt(var_popx);
long double std_popy = sqrt(var_popy);
long double covar_pop = (sumxy - ((sumx * sumy) / N)) / N;
long double corr = covar_pop / (std_popy * std_popx);
valOut = static_cast<double>(corr);
}
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode corr::dropValue(mcsv1Context* context, ColumnDatum* valsDropped)
{
double valy = toDouble(valsDropped[0]);
double valx = toDouble(valsDropped[1]);
struct corr_data* data = (struct corr_data*)context->getUserData()->data;
double valy = toDouble(valsDropped[0]);
double valx = toDouble(valsDropped[1]);
struct corr_data* data = (struct corr_data*)context->getUserData()->data;
data->sumy -= valy;
data->sumy2 -= valy*valy;
data->sumy -= valy;
data->sumy2 -= valy * valy;
data->sumx -= valx;
data->sumx2 -= valx*valx;
data->sumx -= valx;
data->sumx2 -= valx * valx;
data->sumxy -= valx*valy;
--data->cnt;
data->sumxy -= valx * valy;
--data->cnt;
return mcsv1_UDAF::SUCCESS;
return mcsv1_UDAF::SUCCESS;
}

38
utils/regr/corr.h
View File

@ -16,10 +16,10 @@
MA 02110-1301, USA. */
/***********************************************************************
* $Id$
*
* corr.h
***********************************************************************/
* $Id$
*
* corr.h
***********************************************************************/
/**
* Columnstore interface for for the corr function
@ -51,34 +51,30 @@
namespace mcsv1sdk
{
// Return the corr value of the dataset
class corr : public mcsv1_UDAF
class corr : public mcsv1_UDAF
{
public:
// Defaults OK
corr() : mcsv1_UDAF() {};
virtual ~corr() {};
public:
// Defaults OK
corr() : mcsv1_UDAF(){};
virtual ~corr(){};
virtual ReturnCode init(mcsv1Context* context,
ColumnDatum* colTypes);
virtual ReturnCode init(mcsv1Context* context, ColumnDatum* colTypes);
virtual ReturnCode reset(mcsv1Context* context);
virtual ReturnCode reset(mcsv1Context* context);
virtual ReturnCode nextValue(mcsv1Context* context, ColumnDatum* valsIn);
virtual ReturnCode nextValue(mcsv1Context* context, ColumnDatum* valsIn);
virtual ReturnCode subEvaluate(mcsv1Context* context, const UserData* valIn);
virtual ReturnCode subEvaluate(mcsv1Context* context, const UserData* valIn);
virtual ReturnCode evaluate(mcsv1Context* context, static_any::any& valOut);
virtual ReturnCode evaluate(mcsv1Context* context, static_any::any& valOut);
virtual ReturnCode dropValue(mcsv1Context* context, ColumnDatum* valsDropped);
virtual ReturnCode dropValue(mcsv1Context* context, ColumnDatum* valsDropped);
protected:
protected:
};
}; // namespace
}; // namespace mcsv1sdk
#undef EXPORT

160
utils/regr/covar_pop.cpp
View File

@ -26,11 +26,11 @@ using namespace mcsv1sdk;
class Add_covar_pop_ToUDAFMap
{
public:
Add_covar_pop_ToUDAFMap()
{
UDAFMap::getMap()["covar_pop"] = new covar_pop();
}
public:
Add_covar_pop_ToUDAFMap()
{
UDAFMap::getMap()["covar_pop"] = new covar_pop();
}
};
static Add_covar_pop_ToUDAFMap addToMap;
@ -38,113 +38,109 @@ static Add_covar_pop_ToUDAFMap addToMap;
// Use the simple data model
struct covar_pop_data
{
uint64_t cnt;
long double sumx;
long double sumy;
long double sumxy; // sum of x * y
uint64_t cnt;
long double sumx;
long double sumy;
long double sumxy; // sum of x * y
};
mcsv1_UDAF::ReturnCode covar_pop::init(mcsv1Context* context,
ColumnDatum* colTypes)
mcsv1_UDAF::ReturnCode covar_pop::init(mcsv1Context* context, ColumnDatum* colTypes)
{
if (context->getParameterCount() != 2)
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("covar_pop() with other than 2 arguments");
return mcsv1_UDAF::ERROR;
}
if (!(isNumeric(colTypes[0].dataType) && isNumeric(colTypes[1].dataType)))
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("covar_pop() with non-numeric arguments");
return mcsv1_UDAF::ERROR;
}
context->setUserDataSize(sizeof(covar_pop_data));
context->setResultType(execplan::CalpontSystemCatalog::DOUBLE);
context->setColWidth(8);
context->setScale(DECIMAL_NOT_SPECIFIED);
context->setPrecision(0);
context->setRunFlag(mcsv1sdk::UDAF_IGNORE_NULLS);
return mcsv1_UDAF::SUCCESS;
if (context->getParameterCount() != 2)
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("covar_pop() with other than 2 arguments");
return mcsv1_UDAF::ERROR;
}
if (!(isNumeric(colTypes[0].dataType) && isNumeric(colTypes[1].dataType)))
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("covar_pop() with non-numeric arguments");
return mcsv1_UDAF::ERROR;
}
context->setUserDataSize(sizeof(covar_pop_data));
context->setResultType(execplan::CalpontSystemCatalog::DOUBLE);
context->setColWidth(8);
context->setScale(DECIMAL_NOT_SPECIFIED);
context->setPrecision(0);
context->setRunFlag(mcsv1sdk::UDAF_IGNORE_NULLS);
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode covar_pop::reset(mcsv1Context* context)
{
struct covar_pop_data* data = (struct covar_pop_data*)context->getUserData()->data;
data->cnt = 0;
data->sumx = 0.0;
data->sumy = 0.0;
data->sumxy = 0.0;
return mcsv1_UDAF::SUCCESS;
struct covar_pop_data* data = (struct covar_pop_data*)context->getUserData()->data;
data->cnt = 0;
data->sumx = 0.0;
data->sumy = 0.0;
data->sumxy = 0.0;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode covar_pop::nextValue(mcsv1Context* context, ColumnDatum* valsIn)
{
double valy = toDouble(valsIn[0]);
double valx = toDouble(valsIn[1]);
struct covar_pop_data* data = (struct covar_pop_data*)context->getUserData()->data;
double valy = toDouble(valsIn[0]);
double valx = toDouble(valsIn[1]);
struct covar_pop_data* data = (struct covar_pop_data*)context->getUserData()->data;
data->sumy += valy;
data->sumx += valx;
data->sumy += valy;
data->sumx += valx;
data->sumxy += valx*valy;
data->sumxy += valx * valy;
++data->cnt;
return mcsv1_UDAF::SUCCESS;
++data->cnt;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode covar_pop::subEvaluate(mcsv1Context* context, const UserData* userDataIn)
{
if (!userDataIn)
{
return mcsv1_UDAF::SUCCESS;
}
struct covar_pop_data* outData = (struct covar_pop_data*)context->getUserData()->data;
struct covar_pop_data* inData = (struct covar_pop_data*)userDataIn->data;
outData->sumx += inData->sumx;
outData->sumy += inData->sumy;
outData->sumxy += inData->sumxy;
outData->cnt += inData->cnt;
if (!userDataIn)
{
return mcsv1_UDAF::SUCCESS;
}
struct covar_pop_data* outData = (struct covar_pop_data*)context->getUserData()->data;
struct covar_pop_data* inData = (struct covar_pop_data*)userDataIn->data;
outData->sumx += inData->sumx;
outData->sumy += inData->sumy;
outData->sumxy += inData->sumxy;
outData->cnt += inData->cnt;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode covar_pop::evaluate(mcsv1Context* context, static_any::any& valOut)
{
struct covar_pop_data* data = (struct covar_pop_data*)context->getUserData()->data;
double N = data->cnt;
if (N > 0)
{
long double sumx = data->sumx;
long double sumy = data->sumy;
long double sumxy = data->sumxy;
struct covar_pop_data* data = (struct covar_pop_data*)context->getUserData()->data;
double N = data->cnt;
if (N > 0)
{
long double sumx = data->sumx;
long double sumy = data->sumy;
long double sumxy = data->sumxy;
long double covar_pop = (sumxy - ((sumx * sumy) / N)) / N;
valOut = static_cast<double>(covar_pop);
}
return mcsv1_UDAF::SUCCESS;
long double covar_pop = (sumxy - ((sumx * sumy) / N)) / N;
valOut = static_cast<double>(covar_pop);
}
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode covar_pop::dropValue(mcsv1Context* context, ColumnDatum* valsDropped)
{
double valy = toDouble(valsDropped[0]);
double valx = toDouble(valsDropped[1]);
struct covar_pop_data* data = (struct covar_pop_data*)context->getUserData()->data;
double valy = toDouble(valsDropped[0]);
double valx = toDouble(valsDropped[1]);
struct covar_pop_data* data = (struct covar_pop_data*)context->getUserData()->data;
data->sumy -= valy;
data->sumx -= valx;
data->sumy -= valy;
data->sumx -= valx;
data->sumxy -= valx*valy;
--data->cnt;
data->sumxy -= valx * valy;
--data->cnt;
return mcsv1_UDAF::SUCCESS;
return mcsv1_UDAF::SUCCESS;
}

38
utils/regr/covar_pop.h
View File

@ -16,10 +16,10 @@
MA 02110-1301, USA. */
/***********************************************************************
* $Id$
*
* covar_pop.h
***********************************************************************/
* $Id$
*
* covar_pop.h
***********************************************************************/
/**
* Columnstore interface for for the covar_pop function
@ -51,34 +51,30 @@
namespace mcsv1sdk
{
// Return the covar_pop value of the dataset
class covar_pop : public mcsv1_UDAF
class covar_pop : public mcsv1_UDAF
{
public:
// Defaults OK
covar_pop() : mcsv1_UDAF() {};
virtual ~covar_pop() {};
public:
// Defaults OK
covar_pop() : mcsv1_UDAF(){};
virtual ~covar_pop(){};
virtual ReturnCode init(mcsv1Context* context,
ColumnDatum* colTypes);
virtual ReturnCode init(mcsv1Context* context, ColumnDatum* colTypes);
virtual ReturnCode reset(mcsv1Context* context);
virtual ReturnCode reset(mcsv1Context* context);
virtual ReturnCode nextValue(mcsv1Context* context, ColumnDatum* valsIn);
virtual ReturnCode nextValue(mcsv1Context* context, ColumnDatum* valsIn);
virtual ReturnCode subEvaluate(mcsv1Context* context, const UserData* valIn);
virtual ReturnCode subEvaluate(mcsv1Context* context, const UserData* valIn);
virtual ReturnCode evaluate(mcsv1Context* context, static_any::any& valOut);
virtual ReturnCode evaluate(mcsv1Context* context, static_any::any& valOut);
virtual ReturnCode dropValue(mcsv1Context* context, ColumnDatum* valsDropped);
virtual ReturnCode dropValue(mcsv1Context* context, ColumnDatum* valsDropped);
protected:
protected:
};
}; // namespace
}; // namespace mcsv1sdk
#undef EXPORT

169
utils/regr/covar_samp.cpp
View File

@ -26,11 +26,11 @@ using namespace mcsv1sdk;
class Add_covar_samp_ToUDAFMap
{
public:
Add_covar_samp_ToUDAFMap()
{
UDAFMap::getMap()["covar_samp"] = new covar_samp();
}
public:
Add_covar_samp_ToUDAFMap()
{
UDAFMap::getMap()["covar_samp"] = new covar_samp();
}
};
static Add_covar_samp_ToUDAFMap addToMap;
@ -38,120 +38,115 @@ static Add_covar_samp_ToUDAFMap addToMap;
// Use the simple data model
struct covar_samp_data
{
uint64_t cnt;
long double sumx;
long double sumy;
long double sumxy; // sum of x * y
uint64_t cnt;
long double sumx;
long double sumy;
long double sumxy; // sum of x * y
};
mcsv1_UDAF::ReturnCode covar_samp::init(mcsv1Context* context,
ColumnDatum* colTypes)
mcsv1_UDAF::ReturnCode covar_samp::init(mcsv1Context* context, ColumnDatum* colTypes)
{
if (context->getParameterCount() != 2)
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("covar_samp() with other than 2 arguments");
return mcsv1_UDAF::ERROR;
}
if (!(isNumeric(colTypes[0].dataType) && isNumeric(colTypes[1].dataType)))
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("covar_samp() with non-numeric arguments");
return mcsv1_UDAF::ERROR;
}
context->setUserDataSize(sizeof(covar_samp_data));
context->setResultType(execplan::CalpontSystemCatalog::DOUBLE);
context->setColWidth(8);
context->setScale(DECIMAL_NOT_SPECIFIED);
context->setPrecision(0);
context->setRunFlag(mcsv1sdk::UDAF_IGNORE_NULLS);
return mcsv1_UDAF::SUCCESS;
if (context->getParameterCount() != 2)
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("covar_samp() with other than 2 arguments");
return mcsv1_UDAF::ERROR;
}
if (!(isNumeric(colTypes[0].dataType) && isNumeric(colTypes[1].dataType)))
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("covar_samp() with non-numeric arguments");
return mcsv1_UDAF::ERROR;
}
context->setUserDataSize(sizeof(covar_samp_data));
context->setResultType(execplan::CalpontSystemCatalog::DOUBLE);
context->setColWidth(8);
context->setScale(DECIMAL_NOT_SPECIFIED);
context->setPrecision(0);
context->setRunFlag(mcsv1sdk::UDAF_IGNORE_NULLS);
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode covar_samp::reset(mcsv1Context* context)
{
struct covar_samp_data* data = (struct covar_samp_data*)context->getUserData()->data;
data->cnt = 0;
data->sumx = 0.0;
data->sumy = 0.0;
data->sumxy = 0.0;
return mcsv1_UDAF::SUCCESS;
struct covar_samp_data* data = (struct covar_samp_data*)context->getUserData()->data;
data->cnt = 0;
data->sumx = 0.0;
data->sumy = 0.0;
data->sumxy = 0.0;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode covar_samp::nextValue(mcsv1Context* context, ColumnDatum* valsIn)
{
double valy = toDouble(valsIn[0]);
double valx = toDouble(valsIn[1]);
struct covar_samp_data* data = (struct covar_samp_data*)context->getUserData()->data;
double valy = toDouble(valsIn[0]);
double valx = toDouble(valsIn[1]);
struct covar_samp_data* data = (struct covar_samp_data*)context->getUserData()->data;
data->sumy += valy;
data->sumy += valy;
data->sumx += valx;
data->sumx += valx;
data->sumxy += valx*valy;
data->sumxy += valx * valy;
++data->cnt;
return mcsv1_UDAF::SUCCESS;
++data->cnt;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode covar_samp::subEvaluate(mcsv1Context* context, const UserData* userDataIn)
{
if (!userDataIn)
{
return mcsv1_UDAF::SUCCESS;
}
struct covar_samp_data* outData = (struct covar_samp_data*)context->getUserData()->data;
struct covar_samp_data* inData = (struct covar_samp_data*)userDataIn->data;
outData->sumx += inData->sumx;
outData->sumy += inData->sumy;
outData->sumxy += inData->sumxy;
outData->cnt += inData->cnt;
if (!userDataIn)
{
return mcsv1_UDAF::SUCCESS;
}
struct covar_samp_data* outData = (struct covar_samp_data*)context->getUserData()->data;
struct covar_samp_data* inData = (struct covar_samp_data*)userDataIn->data;
outData->sumx += inData->sumx;
outData->sumy += inData->sumy;
outData->sumxy += inData->sumxy;
outData->cnt += inData->cnt;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode covar_samp::evaluate(mcsv1Context* context, static_any::any& valOut)
{
struct covar_samp_data* data = (struct covar_samp_data*)context->getUserData()->data;
double N = data->cnt;
if (N > 1)
{
long double sumx = data->sumx;
long double sumy = data->sumy;
long double sumxy = data->sumxy;
struct covar_samp_data* data = (struct covar_samp_data*)context->getUserData()->data;
double N = data->cnt;
if (N > 1)
{
long double sumx = data->sumx;
long double sumy = data->sumy;
long double sumxy = data->sumxy;
long double covar_samp = (sumxy - ((sumx * sumy) / N)) / (N - 1);
valOut = static_cast<double>(covar_samp);
}
else
if (N == 1)
{
valOut = 0;
}
return mcsv1_UDAF::SUCCESS;
long double covar_samp = (sumxy - ((sumx * sumy) / N)) / (N - 1);
valOut = static_cast<double>(covar_samp);
}
else if (N == 1)
{
valOut = 0;
}
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode covar_samp::dropValue(mcsv1Context* context, ColumnDatum* valsDropped)
{
double valy = toDouble(valsDropped[0]);
double valx = toDouble(valsDropped[1]);
struct covar_samp_data* data = (struct covar_samp_data*)context->getUserData()->data;
double valy = toDouble(valsDropped[0]);
double valx = toDouble(valsDropped[1]);
struct covar_samp_data* data = (struct covar_samp_data*)context->getUserData()->data;
data->sumy -= valy;
data->sumy -= valy;
data->sumx -= valx;
data->sumx -= valx;
data->sumxy -= valx*valy;
--data->cnt;
data->sumxy -= valx * valy;
--data->cnt;
return mcsv1_UDAF::SUCCESS;
return mcsv1_UDAF::SUCCESS;
}

38
utils/regr/covar_samp.h
View File

@ -16,10 +16,10 @@
MA 02110-1301, USA. */
/***********************************************************************
* $Id$
*
* covar_samp.h
***********************************************************************/
* $Id$
*
* covar_samp.h
***********************************************************************/
/**
* Columnstore interface for for the covar_samp function
@ -51,34 +51,30 @@
namespace mcsv1sdk
{
// Return the covar_samp value of the dataset
class covar_samp : public mcsv1_UDAF
class covar_samp : public mcsv1_UDAF
{
public:
// Defaults OK
covar_samp() : mcsv1_UDAF() {};
virtual ~covar_samp() {};
public:
// Defaults OK
covar_samp() : mcsv1_UDAF(){};
virtual ~covar_samp(){};
virtual ReturnCode init(mcsv1Context* context,
ColumnDatum* colTypes);
virtual ReturnCode init(mcsv1Context* context, ColumnDatum* colTypes);
virtual ReturnCode reset(mcsv1Context* context);
virtual ReturnCode reset(mcsv1Context* context);
virtual ReturnCode nextValue(mcsv1Context* context, ColumnDatum* valsIn);
virtual ReturnCode nextValue(mcsv1Context* context, ColumnDatum* valsIn);
virtual ReturnCode subEvaluate(mcsv1Context* context, const UserData* valIn);
virtual ReturnCode subEvaluate(mcsv1Context* context, const UserData* valIn);
virtual ReturnCode evaluate(mcsv1Context* context, static_any::any& valOut);
virtual ReturnCode evaluate(mcsv1Context* context, static_any::any& valOut);
virtual ReturnCode dropValue(mcsv1Context* context, ColumnDatum* valsDropped);
virtual ReturnCode dropValue(mcsv1Context* context, ColumnDatum* valsDropped);
protected:
protected:
};
}; // namespace
}; // namespace mcsv1sdk
#undef EXPORT

806
utils/regr/moda.cpp
View File

@ -29,11 +29,11 @@ using namespace mcsv1sdk;
// map of UDAF for lookup
class Add_moda_ToUDAFMap
{
public:
Add_moda_ToUDAFMap()
{
UDAFMap::getMap()["moda"] = new moda();
}
public:
Add_moda_ToUDAFMap()
{
UDAFMap::getMap()["moda"] = new moda();
}
};
static Add_moda_ToUDAFMap addToMap;
@ -55,8 +55,8 @@ static Add_moda_ToUDAFMap addToMap;
// This class implements option 3 by creating templated classes.
// There are two moda classes, the main one called moda, which is basically
// an adapter (Pattern) to the templated class called Moda_impl_T.
//
// The way the API works, each function class is instantiated exactly once per
//
// The way the API works, each function class is instantiated exactly once per
// executable and then accessed via a map. This means that the function classes
// could be used by any active query, or more than once by a single query. These
// classes have no data fields for this reason. All data for a specific query is
@ -65,518 +65,410 @@ static Add_moda_ToUDAFMap addToMap;
// Each possible templated instantation is created ate moda creation during startup.
// They are the Moda_impl_T members at the bottom of the moda class definition.
// At runtime getImpl() gets the right one for the datatype involved based on context.
//
//
// More template magic is done in the ModaData class to create and maintained
// a hash of the correct type.
// getImpl returns the current modaImpl or gets the correct one based on context.
mcsv1_UDAF* moda::getImpl(mcsv1Context* context)
{
ModaData* data = static_cast<ModaData*>(context->getUserData());
if (data->modaImpl)
return data->modaImpl;
switch (context->getResultType())
{
case execplan::CalpontSystemCatalog::TINYINT:
data->modaImpl = &moda_impl_int8;
break;
case execplan::CalpontSystemCatalog::SMALLINT:
data->modaImpl = &moda_impl_int16;
break;
case execplan::CalpontSystemCatalog::MEDINT:
case execplan::CalpontSystemCatalog::INT:
data->modaImpl = &moda_impl_int32;
break;
case execplan::CalpontSystemCatalog::BIGINT:
data->modaImpl = &moda_impl_int64;
break;
case execplan::CalpontSystemCatalog::DECIMAL:
case execplan::CalpontSystemCatalog::UDECIMAL:
switch (context->getColWidth())
{
case 1:
data->modaImpl = &moda_impl_int8;
break;
case 2:
data->modaImpl = &moda_impl_int16;
break;
case 4:
data->modaImpl = &moda_impl_int32;
break;
case 8:
data->modaImpl = &moda_impl_int64;
break;
case 16:
data->modaImpl = &moda_impl_int128;
break;
}
break;
case execplan::CalpontSystemCatalog::UTINYINT:
data->modaImpl = &moda_impl_uint8;
break;
case execplan::CalpontSystemCatalog::USMALLINT:
data->modaImpl = &moda_impl_uint16;
break;
case execplan::CalpontSystemCatalog::UMEDINT:
case execplan::CalpontSystemCatalog::UINT:
data->modaImpl = &moda_impl_uint32;
break;
case execplan::CalpontSystemCatalog::UBIGINT:
data->modaImpl = &moda_impl_uint64;
break;
case execplan::CalpontSystemCatalog::FLOAT:
data->modaImpl = &moda_impl_float;
break;
case execplan::CalpontSystemCatalog::DOUBLE:
data->modaImpl = &moda_impl_double;
break;
case execplan::CalpontSystemCatalog::LONGDOUBLE:
data->modaImpl = &moda_impl_longdouble;
break;
default:
data->modaImpl = NULL;
}
ModaData* data = static_cast<ModaData*>(context->getUserData());
if (data->modaImpl)
return data->modaImpl;
switch (context->getResultType())
{
case execplan::CalpontSystemCatalog::TINYINT: data->modaImpl = &moda_impl_int8; break;
case execplan::CalpontSystemCatalog::SMALLINT: data->modaImpl = &moda_impl_int16; break;
case execplan::CalpontSystemCatalog::MEDINT:
case execplan::CalpontSystemCatalog::INT: data->modaImpl = &moda_impl_int32; break;
case execplan::CalpontSystemCatalog::BIGINT: data->modaImpl = &moda_impl_int64; break;
case execplan::CalpontSystemCatalog::DECIMAL:
case execplan::CalpontSystemCatalog::UDECIMAL:
switch (context->getColWidth())
{
case 1: data->modaImpl = &moda_impl_int8; break;
case 2: data->modaImpl = &moda_impl_int16; break;
case 4: data->modaImpl = &moda_impl_int32; break;
case 8: data->modaImpl = &moda_impl_int64; break;
case 16: data->modaImpl = &moda_impl_int128; break;
}
break;
case execplan::CalpontSystemCatalog::UTINYINT: data->modaImpl = &moda_impl_uint8; break;
case execplan::CalpontSystemCatalog::USMALLINT: data->modaImpl = &moda_impl_uint16; break;
case execplan::CalpontSystemCatalog::UMEDINT:
case execplan::CalpontSystemCatalog::UINT: data->modaImpl = &moda_impl_uint32; break;
case execplan::CalpontSystemCatalog::UBIGINT: data->modaImpl = &moda_impl_uint64; break;
case execplan::CalpontSystemCatalog::FLOAT: data->modaImpl = &moda_impl_float; break;
case execplan::CalpontSystemCatalog::DOUBLE: data->modaImpl = &moda_impl_double; break;
case execplan::CalpontSystemCatalog::LONGDOUBLE: data->modaImpl = &moda_impl_longdouble; break;
default: data->modaImpl = NULL;
}
return data->modaImpl;
}
mcsv1_UDAF::ReturnCode moda::init(mcsv1Context* context,
ColumnDatum* colTypes)
mcsv1_UDAF::ReturnCode moda::init(mcsv1Context* context, ColumnDatum* colTypes)
{
if (context->getParameterCount() < 1)
if (context->getParameterCount() < 1)
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("moda() with 0 arguments");
return mcsv1_UDAF::ERROR;
}
if (context->getParameterCount() > 1)
{
context->setErrorMessage("moda() with more than 1 argument");
return mcsv1_UDAF::ERROR;
}
if (!(datatypes::isNumeric(colTypes[0].dataType)))
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("moda() with non-numeric argument");
return mcsv1_UDAF::ERROR;
}
context->setResultType(colTypes[0].dataType);
if (colTypes[0].dataType == execplan::CalpontSystemCatalog::DECIMAL ||
colTypes[0].dataType == execplan::CalpontSystemCatalog::UDECIMAL)
{
if (colTypes[0].precision < 3)
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("moda() with 0 arguments");
return mcsv1_UDAF::ERROR;
context->setColWidth(1);
}
else if (colTypes[0].precision < 4)
{
context->setColWidth(2);
}
else if (colTypes[0].precision < 9)
{
context->setColWidth(4);
}
else if (colTypes[0].precision < 19)
{
context->setColWidth(8);
}
else if (utils::widthByPrecision(colTypes[0].precision))
{
context->setColWidth(16);
}
if (context->getParameterCount() > 1)
{
context->setErrorMessage("moda() with more than 1 argument");
return mcsv1_UDAF::ERROR;
}
context->setScale(colTypes[0].scale);
}
context->setPrecision(colTypes[0].precision);
if (!(datatypes::isNumeric(colTypes[0].dataType)))
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("moda() with non-numeric argument");
return mcsv1_UDAF::ERROR;
}
context->setResultType(colTypes[0].dataType);
mcsv1_UDAF* impl = getImpl(context);
if (colTypes[0].dataType == execplan::CalpontSystemCatalog::DECIMAL
|| colTypes[0].dataType == execplan::CalpontSystemCatalog::UDECIMAL)
{
if (colTypes[0].precision < 3)
{
context->setColWidth(1);
}
else if (colTypes[0].precision < 4)
{
context->setColWidth(2);
}
else if (colTypes[0].precision < 9)
{
context->setColWidth(4);
}
else if (colTypes[0].precision < 19)
{
context->setColWidth(8);
}
else if (utils::widthByPrecision(colTypes[0].precision))
{
context->setColWidth(16);
}
context->setScale(colTypes[0].scale);
}
context->setPrecision(colTypes[0].precision);
mcsv1_UDAF* impl = getImpl(context);
if (!impl)
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("moda() with non-numeric argument");
return mcsv1_UDAF::ERROR;
}
if (!impl)
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("moda() with non-numeric argument");
return mcsv1_UDAF::ERROR;
}
context->setRunFlag(mcsv1sdk::UDAF_IGNORE_NULLS);
return impl->init(context, colTypes);
context->setRunFlag(mcsv1sdk::UDAF_IGNORE_NULLS);
return impl->init(context, colTypes);
}
template<class T>
mcsv1_UDAF::ReturnCode Moda_impl_T<T>::init(mcsv1Context* context,
ColumnDatum* colTypes)
template <class T>
mcsv1_UDAF::ReturnCode Moda_impl_T<T>::init(mcsv1Context* context, ColumnDatum* colTypes)
{
return mcsv1_UDAF::SUCCESS;
return mcsv1_UDAF::SUCCESS;
}
template<class T>
template <class T>
mcsv1_UDAF::ReturnCode Moda_impl_T<T>::reset(mcsv1Context* context)
{
ModaData* data = static_cast<ModaData*>(context->getUserData());
data->fReturnType = context->getResultType();
data->fColWidth = context->getColWidth();
data->clear<T>();
return mcsv1_UDAF::SUCCESS;
ModaData* data = static_cast<ModaData*>(context->getUserData());
data->fReturnType = context->getResultType();
data->fColWidth = context->getColWidth();
data->clear<T>();
return mcsv1_UDAF::SUCCESS;
}
template<class T>
template <class T>
mcsv1_UDAF::ReturnCode Moda_impl_T<T>::nextValue(mcsv1Context* context, ColumnDatum* valsIn)
{
static_any::any& valIn = valsIn[0].columnData;
ModaData* data = static_cast<ModaData*>(context->getUserData());
std::unordered_map<T, uint32_t, hasher<T> >* map = data->getMap<T>();
static_any::any& valIn = valsIn[0].columnData;
ModaData* data = static_cast<ModaData*>(context->getUserData());
std::unordered_map<T, uint32_t, hasher<T> >* map = data->getMap<T>();
if (valIn.empty())
if (valIn.empty())
{
return mcsv1_UDAF::SUCCESS; // Ought not happen when UDAF_IGNORE_NULLS is on.
}
T val = convertAnyTo<T>(valIn);
if (context->getResultType() == execplan::CalpontSystemCatalog::DOUBLE)
{
// For decimal types, we need to move the decimal point.
uint32_t scale = valsIn[0].scale;
if (val != 0 && scale > 0)
{
return mcsv1_UDAF::SUCCESS; // Ought not happen when UDAF_IGNORE_NULLS is on.
val /= datatypes::scaleDivisor<double>(scale);
}
}
T val = convertAnyTo<T>(valIn);
data->fSum += val;
++data->fCount;
(*map)[val]++;
if (context->getResultType() == execplan::CalpontSystemCatalog::DOUBLE)
{
// For decimal types, we need to move the decimal point.
uint32_t scale = valsIn[0].scale;
if (val != 0 && scale > 0)
{
val /= datatypes::scaleDivisor<double>(scale);
}
}
data->fSum += val;
++data->fCount;
(*map)[val]++;
return mcsv1_UDAF::SUCCESS;
return mcsv1_UDAF::SUCCESS;
}
template<class T>
template <class T>
mcsv1_UDAF::ReturnCode Moda_impl_T<T>::subEvaluate(mcsv1Context* context, const UserData* userDataIn)
{
if (!userDataIn)
{
return mcsv1_UDAF::SUCCESS;
}
ModaData* outData = static_cast<ModaData*>(context->getUserData());
const ModaData* inData = static_cast<const ModaData*>(userDataIn);
std::unordered_map<T, uint32_t, hasher<T> >* outMap = outData->getMap<T>();
std::unordered_map<T, uint32_t, hasher<T> >* inMap = inData->getMap<T>();
typename std::unordered_map<T, uint32_t, hasher<T> >::const_iterator iter;
for (iter = inMap->begin(); iter != inMap->end(); ++iter)
{
(*outMap)[iter->first] += iter->second;
}
// AVG
outData->fSum += inData->fSum;
outData->fCount += inData->fCount;
if (!userDataIn)
{
return mcsv1_UDAF::SUCCESS;
}
ModaData* outData = static_cast<ModaData*>(context->getUserData());
const ModaData* inData = static_cast<const ModaData*>(userDataIn);
std::unordered_map<T, uint32_t, hasher<T> >* outMap = outData->getMap<T>();
std::unordered_map<T, uint32_t, hasher<T> >* inMap = inData->getMap<T>();
typename std::unordered_map<T, uint32_t, hasher<T> >::const_iterator iter;
for (iter = inMap->begin(); iter != inMap->end(); ++iter)
{
(*outMap)[iter->first] += iter->second;
}
// AVG
outData->fSum += inData->fSum;
outData->fCount += inData->fCount;
return mcsv1_UDAF::SUCCESS;
}
template<class T>
template <class T>
mcsv1_UDAF::ReturnCode Moda_impl_T<T>::evaluate(mcsv1Context* context, static_any::any& valOut)
{
uint64_t maxCnt = 0;
long double avg = 0;
T val = 0;
ModaData* data = static_cast<ModaData*>(context->getUserData());
std::unordered_map<T, uint32_t, hasher<T> >* map = data->getMap<T>();
uint64_t maxCnt = 0;
long double avg = 0;
T val = 0;
ModaData* data = static_cast<ModaData*>(context->getUserData());
std::unordered_map<T, uint32_t, hasher<T> >* map = data->getMap<T>();
if (map->size() == 0)
{
valOut = (T)0;
return mcsv1_UDAF::SUCCESS;
}
avg = data->fCount ? data->fSum / data->fCount : 0;
typename std::unordered_map<T, uint32_t, hasher<T> >::iterator iter;
for (iter = map->begin(); iter != map->end(); ++iter)
{
if (iter->second > maxCnt)
{
val = iter->first;
maxCnt = iter->second;
}
else if (iter->second == maxCnt)
{
T absval = val >= 0 ? val : -val;
T absfirst = iter->first >= 0 ? iter->first : -iter->first;
// Tie breaker: choose the closest to avg. If still tie, choose smallest
long double dist1 = val > avg ? (long double)val-avg : avg-(long double)val;
long double dist2 = iter->first > avg ? (long double)iter->first-avg : avg-(long double)iter->first;
if ((dist1 > dist2)
|| ((dist1 == dist2) && (absval > absfirst)))
{
val = iter->first;
}
}
}
// If scale is > 0, then the original type was DECIMAL. Set the
// ResultType to DECIMAL so the delivery logic moves the decimal point.
if (context->getScale() > 0)
context->setResultType(execplan::CalpontSystemCatalog::DECIMAL);
valOut = val;
if (map->size() == 0)
{
valOut = (T)0;
return mcsv1_UDAF::SUCCESS;
}
avg = data->fCount ? data->fSum / data->fCount : 0;
typename std::unordered_map<T, uint32_t, hasher<T> >::iterator iter;
for (iter = map->begin(); iter != map->end(); ++iter)
{
if (iter->second > maxCnt)
{
val = iter->first;
maxCnt = iter->second;
}
else if (iter->second == maxCnt)
{
T absval = val >= 0 ? val : -val;
T absfirst = iter->first >= 0 ? iter->first : -iter->first;
// Tie breaker: choose the closest to avg. If still tie, choose smallest
long double dist1 = val > avg ? (long double)val - avg : avg - (long double)val;
long double dist2 = iter->first > avg ? (long double)iter->first - avg : avg - (long double)iter->first;
if ((dist1 > dist2) || ((dist1 == dist2) && (absval > absfirst)))
{
val = iter->first;
}
}
}
// If scale is > 0, then the original type was DECIMAL. Set the
// ResultType to DECIMAL so the delivery logic moves the decimal point.
if (context->getScale() > 0)
context->setResultType(execplan::CalpontSystemCatalog::DECIMAL);
valOut = val;
return mcsv1_UDAF::SUCCESS;
}
template<class T>
template <class T>
mcsv1_UDAF::ReturnCode Moda_impl_T<T>::dropValue(mcsv1Context* context, ColumnDatum* valsDropped)
{
static_any::any& valDropped = valsDropped[0].columnData;
ModaData* data = static_cast<ModaData*>(context->getUserData());
std::unordered_map<T, uint32_t, hasher<T> >* map = data->getMap<T>();
static_any::any& valDropped = valsDropped[0].columnData;
ModaData* data = static_cast<ModaData*>(context->getUserData());
std::unordered_map<T, uint32_t, hasher<T> >* map = data->getMap<T>();
if (valDropped.empty())
{
return mcsv1_UDAF::SUCCESS; // Ought not happen when UDAF_IGNORE_NULLS is on.
}
if (valDropped.empty())
{
return mcsv1_UDAF::SUCCESS; // Ought not happen when UDAF_IGNORE_NULLS is on.
}
T val = convertAnyTo<T>(valDropped);
T val = convertAnyTo<T>(valDropped);
data->fSum -= val;
--data->fCount;
(*map)[val]--;
data->fSum -= val;
--data->fCount;
(*map)[val]--;
return mcsv1_UDAF::SUCCESS;
return mcsv1_UDAF::SUCCESS;
}
void ModaData::serialize(messageqcpp::ByteStream& bs) const
{
bs << fReturnType;
bs << fSum;
bs << fCount;
bs << fColWidth;
switch ((execplan::CalpontSystemCatalog::ColDataType)fReturnType)
{
case execplan::CalpontSystemCatalog::TINYINT:
serializeMap<int8_t>(bs);
break;
case execplan::CalpontSystemCatalog::SMALLINT:
serializeMap<int16_t>(bs);
break;
case execplan::CalpontSystemCatalog::MEDINT:
case execplan::CalpontSystemCatalog::INT:
serializeMap<int32_t>(bs);
break;
case execplan::CalpontSystemCatalog::BIGINT:
serializeMap<int64_t>(bs);
break;
case execplan::CalpontSystemCatalog::DECIMAL:
case execplan::CalpontSystemCatalog::UDECIMAL:
switch (fColWidth)
{
case 1:
serializeMap<int8_t>(bs);
break;
case 2:
serializeMap<int16_t>(bs);
break;
case 4:
serializeMap<int32_t>(bs);
break;
case 8:
serializeMap<int64_t>(bs);
break;
case 16:
serializeMap<int128_t>(bs);
break;
}
break;
case execplan::CalpontSystemCatalog::UTINYINT:
serializeMap<uint8_t>(bs);
break;
case execplan::CalpontSystemCatalog::USMALLINT:
serializeMap<uint16_t>(bs);
break;
case execplan::CalpontSystemCatalog::UMEDINT:
case execplan::CalpontSystemCatalog::UINT:
serializeMap<uint32_t>(bs);
break;
case execplan::CalpontSystemCatalog::UBIGINT:
serializeMap<uint64_t>(bs);
break;
case execplan::CalpontSystemCatalog::FLOAT:
serializeMap<float>(bs);
break;
case execplan::CalpontSystemCatalog::DOUBLE:
serializeMap<double>(bs);
break;
case execplan::CalpontSystemCatalog::LONGDOUBLE:
serializeMap<long double>(bs);
break;
default:
throw std::runtime_error("ModaData::serialize with bad data type");
break;
}
bs << fReturnType;
bs << fSum;
bs << fCount;
bs << fColWidth;
switch ((execplan::CalpontSystemCatalog::ColDataType)fReturnType)
{
case execplan::CalpontSystemCatalog::TINYINT: serializeMap<int8_t>(bs); break;
case execplan::CalpontSystemCatalog::SMALLINT: serializeMap<int16_t>(bs); break;
case execplan::CalpontSystemCatalog::MEDINT:
case execplan::CalpontSystemCatalog::INT: serializeMap<int32_t>(bs); break;
case execplan::CalpontSystemCatalog::BIGINT: serializeMap<int64_t>(bs); break;
case execplan::CalpontSystemCatalog::DECIMAL:
case execplan::CalpontSystemCatalog::UDECIMAL:
switch (fColWidth)
{
case 1: serializeMap<int8_t>(bs); break;
case 2: serializeMap<int16_t>(bs); break;
case 4: serializeMap<int32_t>(bs); break;
case 8: serializeMap<int64_t>(bs); break;
case 16: serializeMap<int128_t>(bs); break;
}
break;
case execplan::CalpontSystemCatalog::UTINYINT: serializeMap<uint8_t>(bs); break;
case execplan::CalpontSystemCatalog::USMALLINT: serializeMap<uint16_t>(bs); break;
case execplan::CalpontSystemCatalog::UMEDINT:
case execplan::CalpontSystemCatalog::UINT: serializeMap<uint32_t>(bs); break;
case execplan::CalpontSystemCatalog::UBIGINT: serializeMap<uint64_t>(bs); break;
case execplan::CalpontSystemCatalog::FLOAT: serializeMap<float>(bs); break;
case execplan::CalpontSystemCatalog::DOUBLE: serializeMap<double>(bs); break;
case execplan::CalpontSystemCatalog::LONGDOUBLE: serializeMap<long double>(bs); break;
default: throw std::runtime_error("ModaData::serialize with bad data type"); break;
}
}
void ModaData::unserialize(messageqcpp::ByteStream& bs)
{
bs >> fReturnType;
bs >> fSum;
bs >> fCount;
bs >> fColWidth;
bs >> fReturnType;
bs >> fSum;
bs >> fCount;
bs >> fColWidth;
switch ((execplan::CalpontSystemCatalog::ColDataType)fReturnType)
{
case execplan::CalpontSystemCatalog::TINYINT:
unserializeMap<int8_t>(bs);
break;
case execplan::CalpontSystemCatalog::SMALLINT:
unserializeMap<int16_t>(bs);
break;
case execplan::CalpontSystemCatalog::MEDINT:
case execplan::CalpontSystemCatalog::INT:
unserializeMap<int32_t>(bs);
break;
case execplan::CalpontSystemCatalog::BIGINT:
unserializeMap<int64_t>(bs);
break;
case execplan::CalpontSystemCatalog::DECIMAL:
case execplan::CalpontSystemCatalog::UDECIMAL:
switch (fColWidth)
{
case 1:
unserializeMap<int8_t>(bs);
break;
case 2:
unserializeMap<int16_t>(bs);
break;
case 4:
unserializeMap<int32_t>(bs);
break;
case 8:
unserializeMap<int64_t>(bs);
break;
case 16:
unserializeMap<int128_t>(bs);
break;
}
break;
case execplan::CalpontSystemCatalog::UTINYINT:
unserializeMap<uint8_t>(bs);
break;
case execplan::CalpontSystemCatalog::USMALLINT:
unserializeMap<uint16_t>(bs);
break;
case execplan::CalpontSystemCatalog::UMEDINT:
case execplan::CalpontSystemCatalog::UINT:
unserializeMap<uint32_t>(bs);
break;
case execplan::CalpontSystemCatalog::UBIGINT:
unserializeMap<uint64_t>(bs);
break;
case execplan::CalpontSystemCatalog::FLOAT:
unserializeMap<float>(bs);
break;
case execplan::CalpontSystemCatalog::DOUBLE:
unserializeMap<double>(bs);
break;
case execplan::CalpontSystemCatalog::LONGDOUBLE:
unserializeMap<long double>(bs);
break;
default:
throw std::runtime_error("ModaData::unserialize with bad data type");
break;
}
switch ((execplan::CalpontSystemCatalog::ColDataType)fReturnType)
{
case execplan::CalpontSystemCatalog::TINYINT: unserializeMap<int8_t>(bs); break;
case execplan::CalpontSystemCatalog::SMALLINT: unserializeMap<int16_t>(bs); break;
case execplan::CalpontSystemCatalog::MEDINT:
case execplan::CalpontSystemCatalog::INT: unserializeMap<int32_t>(bs); break;
case execplan::CalpontSystemCatalog::BIGINT: unserializeMap<int64_t>(bs); break;
case execplan::CalpontSystemCatalog::DECIMAL:
case execplan::CalpontSystemCatalog::UDECIMAL:
switch (fColWidth)
{
case 1: unserializeMap<int8_t>(bs); break;
case 2: unserializeMap<int16_t>(bs); break;
case 4: unserializeMap<int32_t>(bs); break;
case 8: unserializeMap<int64_t>(bs); break;
case 16: unserializeMap<int128_t>(bs); break;
}
break;
case execplan::CalpontSystemCatalog::UTINYINT: unserializeMap<uint8_t>(bs); break;
case execplan::CalpontSystemCatalog::USMALLINT: unserializeMap<uint16_t>(bs); break;
case execplan::CalpontSystemCatalog::UMEDINT:
case execplan::CalpontSystemCatalog::UINT: unserializeMap<uint32_t>(bs); break;
case execplan::CalpontSystemCatalog::UBIGINT: unserializeMap<uint64_t>(bs); break;
case execplan::CalpontSystemCatalog::FLOAT: unserializeMap<float>(bs); break;
case execplan::CalpontSystemCatalog::DOUBLE: unserializeMap<double>(bs); break;
case execplan::CalpontSystemCatalog::LONGDOUBLE: unserializeMap<long double>(bs); break;
default: throw std::runtime_error("ModaData::unserialize with bad data type"); break;
}
}
void ModaData::cleanup()
{
if (!fMap)
return;
switch ((execplan::CalpontSystemCatalog::ColDataType)fReturnType)
{
case execplan::CalpontSystemCatalog::TINYINT:
clear<int8_t>();
deleteMap<int8_t>();
break;
case execplan::CalpontSystemCatalog::SMALLINT:
clear<int16_t>();
deleteMap<int16_t>();
break;
case execplan::CalpontSystemCatalog::MEDINT:
case execplan::CalpontSystemCatalog::INT:
clear<int32_t>();
deleteMap<int32_t>();
break;
case execplan::CalpontSystemCatalog::BIGINT:
clear<int64_t>();
deleteMap<int64_t>();
break;
case execplan::CalpontSystemCatalog::DECIMAL:
case execplan::CalpontSystemCatalog::UDECIMAL:
switch (fColWidth)
{
case 1:
clear<int8_t>();
deleteMap<int8_t>();
break;
case 2:
clear<int16_t>();
deleteMap<int16_t>();
break;
case 4:
clear<int32_t>();
deleteMap<int32_t>();
break;
case 8:
clear<int64_t>();
deleteMap<int64_t>();
break;
case 16:
clear<int128_t>();
deleteMap<int128_t>();
break;
}
break;
case execplan::CalpontSystemCatalog::UTINYINT:
clear<uint8_t>();
deleteMap<uint8_t>();
break;
case execplan::CalpontSystemCatalog::USMALLINT:
clear<uint16_t>();
deleteMap<uint16_t>();
break;
case execplan::CalpontSystemCatalog::UMEDINT:
case execplan::CalpontSystemCatalog::UINT:
clear<uint32_t>();
deleteMap<uint32_t>();
break;
case execplan::CalpontSystemCatalog::UBIGINT:
clear<uint64_t>();
deleteMap<uint64_t>();
break;
case execplan::CalpontSystemCatalog::FLOAT:
clear<float>();
deleteMap<float>();
break;
case execplan::CalpontSystemCatalog::DOUBLE:
clear<double>();
deleteMap<double>();
break;
case execplan::CalpontSystemCatalog::LONGDOUBLE:
clear<long double>();
deleteMap<long double>();
break;
default:
throw std::runtime_error("ModaData::unserialize with bad data type");
break;
}
if (!fMap)
return;
switch ((execplan::CalpontSystemCatalog::ColDataType)fReturnType)
{
case execplan::CalpontSystemCatalog::TINYINT:
clear<int8_t>();
deleteMap<int8_t>();
break;
case execplan::CalpontSystemCatalog::SMALLINT:
clear<int16_t>();
deleteMap<int16_t>();
break;
case execplan::CalpontSystemCatalog::MEDINT:
case execplan::CalpontSystemCatalog::INT:
clear<int32_t>();
deleteMap<int32_t>();
break;
case execplan::CalpontSystemCatalog::BIGINT:
clear<int64_t>();
deleteMap<int64_t>();
break;
case execplan::CalpontSystemCatalog::DECIMAL:
case execplan::CalpontSystemCatalog::UDECIMAL:
switch (fColWidth)
{
case 1:
clear<int8_t>();
deleteMap<int8_t>();
break;
case 2:
clear<int16_t>();
deleteMap<int16_t>();
break;
case 4:
clear<int32_t>();
deleteMap<int32_t>();
break;
case 8:
clear<int64_t>();
deleteMap<int64_t>();
break;
case 16:
clear<int128_t>();
deleteMap<int128_t>();
break;
}
break;
case execplan::CalpontSystemCatalog::UTINYINT:
clear<uint8_t>();
deleteMap<uint8_t>();
break;
case execplan::CalpontSystemCatalog::USMALLINT:
clear<uint16_t>();
deleteMap<uint16_t>();
break;
case execplan::CalpontSystemCatalog::UMEDINT:
case execplan::CalpontSystemCatalog::UINT:
clear<uint32_t>();
deleteMap<uint32_t>();
break;
case execplan::CalpontSystemCatalog::UBIGINT:
clear<uint64_t>();
deleteMap<uint64_t>();
break;
case execplan::CalpontSystemCatalog::FLOAT:
clear<float>();
deleteMap<float>();
break;
case execplan::CalpontSystemCatalog::DOUBLE:
clear<double>();
deleteMap<double>();
break;
case execplan::CalpontSystemCatalog::LONGDOUBLE:
clear<long double>();
deleteMap<long double>();
break;
default: throw std::runtime_error("ModaData::unserialize with bad data type"); break;
}
}

367
utils/regr/moda.h
View File

@ -16,10 +16,10 @@
MA 02110-1301, USA. */
/***********************************************************************
* $Id$
*
* moda.h
***********************************************************************/
* $Id$
*
* moda.h
***********************************************************************/
/**
* Columnstore interface for the moda User Defined Aggregate
@ -54,231 +54,230 @@
namespace mcsv1sdk
{
// A hasher that handles int128_t
template<class T>
// A hasher that handles int128_t
template <class T>
struct hasher
{
inline size_t operator()(T val) const
{
return fHasher((char*) &val, sizeof(T));
}
inline size_t operator()(T val) const
{
return fHasher((char*)&val, sizeof(T));
}
private:
utils::Hasher fHasher;
private:
utils::Hasher fHasher;
};
template<>
template <>
struct hasher<long double>
{
inline size_t operator()(long double val) const
inline size_t operator()(long double val) const
{
if (sizeof(long double) == 8) // Probably just MSC, but you never know.
{
if (sizeof(long double) == 8) // Probably just MSC, but you never know.
{
return fHasher((char*) &val, sizeof(long double));
}
else
{
// For Linux x86_64, long double is stored in 128 bits, but only 80 are significant
return fHasher((char*) &val, 10);
}
return fHasher((char*)&val, sizeof(long double));
}
private:
utils::Hasher fHasher;
else
{
// For Linux x86_64, long double is stored in 128 bits, but only 80 are significant
return fHasher((char*)&val, 10);
}
}
private:
utils::Hasher fHasher;
};
// Override UserData for data storage
struct ModaData : public UserData
{
ModaData() : fMap(NULL),
fReturnType((uint32_t)execplan::CalpontSystemCatalog::UNDEFINED),
fColWidth(0),
modaImpl(NULL)
{};
ModaData()
: fMap(NULL)
, fReturnType((uint32_t)execplan::CalpontSystemCatalog::UNDEFINED)
, fColWidth(0)
, modaImpl(NULL){};
virtual ~ModaData() {cleanup();}
virtual ~ModaData()
{
cleanup();
}
virtual void serialize(messageqcpp::ByteStream& bs) const;
virtual void unserialize(messageqcpp::ByteStream& bs);
virtual void serialize(messageqcpp::ByteStream& bs) const;
virtual void unserialize(messageqcpp::ByteStream& bs);
template<class T>
std::unordered_map<T, uint32_t, hasher<T> >* getMap()
template <class T>
std::unordered_map<T, uint32_t, hasher<T> >* getMap()
{
if (!fMap)
{
if (!fMap)
{
// Just in time creation
fMap = new std::unordered_map<T, uint32_t, hasher<T> >;
}
return (std::unordered_map<T, uint32_t, hasher<T> >*) fMap;
}
// The const version is only called by serialize()
// It shouldn't (and can't) create a new map.
template<class T>
std::unordered_map<T, uint32_t, hasher<T> >* getMap() const
{
return (std::unordered_map<T, uint32_t, hasher<T> >*) fMap;
}
template<class T>
void deleteMap()
{
if (fMap)
{
delete (std::unordered_map<T, uint32_t, hasher<T> >*) fMap;
fMap = NULL;
}
}
template<class T>
void clear()
{
fSum = 0.0;
fCount = 0;
if (fMap)
getMap<T>()->clear();
// Just in time creation
fMap = new std::unordered_map<T, uint32_t, hasher<T> >;
}
return (std::unordered_map<T, uint32_t, hasher<T> >*)fMap;
}
long double fSum;
uint64_t fCount;
void* fMap; // Will be of type unordered_map<>
uint32_t fReturnType;
uint32_t fColWidth;
mcsv1_UDAF* modaImpl; // A pointer to one of the Moda_impl_T concrete classes
private:
// For now, copy construction is unwanted
ModaData(UserData&);
void cleanup();
// Templated map streamers
template<class T>
void serializeMap(messageqcpp::ByteStream& bs) const
// The const version is only called by serialize()
// It shouldn't (and can't) create a new map.
template <class T>
std::unordered_map<T, uint32_t, hasher<T> >* getMap() const
{
return (std::unordered_map<T, uint32_t, hasher<T> >*)fMap;
}
template <class T>
void deleteMap()
{
if (fMap)
{
std::unordered_map<T, uint32_t, hasher<T> >* map = getMap<T>();
if (map)
{
typename std::unordered_map<T, uint32_t, hasher<T> >::const_iterator iter;
bs << (uint64_t)map->size();
for (iter = map->begin(); iter != map->end(); ++iter)
{
bs << iter->first;
bs << iter->second;
}
}
else
{
bs << (uint64_t)0;
}
delete (std::unordered_map<T, uint32_t, hasher<T> >*)fMap;
fMap = NULL;
}
template<class T>
void unserializeMap(messageqcpp::ByteStream& bs)
}
template <class T>
void clear()
{
fSum = 0.0;
fCount = 0;
if (fMap)
getMap<T>()->clear();
}
long double fSum;
uint64_t fCount;
void* fMap; // Will be of type unordered_map<>
uint32_t fReturnType;
uint32_t fColWidth;
mcsv1_UDAF* modaImpl; // A pointer to one of the Moda_impl_T concrete classes
private:
// For now, copy construction is unwanted
ModaData(UserData&);
void cleanup();
// Templated map streamers
template <class T>
void serializeMap(messageqcpp::ByteStream& bs) const
{
std::unordered_map<T, uint32_t, hasher<T> >* map = getMap<T>();
if (map)
{
uint32_t cnt;
T num;
uint64_t sz;
bs >> sz;
std::unordered_map<T, uint32_t, hasher<T> >* map = getMap<T>();
map->clear();
for (uint64_t i = 0; i < sz; ++i)
{
bs >> num;
bs >> cnt;
(*map)[num] = cnt;
}
typename std::unordered_map<T, uint32_t, hasher<T> >::const_iterator iter;
bs << (uint64_t)map->size();
for (iter = map->begin(); iter != map->end(); ++iter)
{
bs << iter->first;
bs << iter->second;
}
}
else
{
bs << (uint64_t)0;
}
}
template <class T>
void unserializeMap(messageqcpp::ByteStream& bs)
{
uint32_t cnt;
T num;
uint64_t sz;
bs >> sz;
std::unordered_map<T, uint32_t, hasher<T> >* map = getMap<T>();
map->clear();
for (uint64_t i = 0; i < sz; ++i)
{
bs >> num;
bs >> cnt;
(*map)[num] = cnt;
}
}
};
template<class T>
template <class T>
class Moda_impl_T : public mcsv1_UDAF
{
public:
// Defaults OK
Moda_impl_T() {};
virtual ~Moda_impl_T() {};
public:
// Defaults OK
Moda_impl_T(){};
virtual ~Moda_impl_T(){};
virtual mcsv1_UDAF::ReturnCode init(mcsv1Context* context,
ColumnDatum* colTypes);
virtual mcsv1_UDAF::ReturnCode init(mcsv1Context* context, ColumnDatum* colTypes);
virtual mcsv1_UDAF::ReturnCode reset(mcsv1Context* context);
virtual mcsv1_UDAF::ReturnCode nextValue(mcsv1Context* context, ColumnDatum* valsIn);
virtual mcsv1_UDAF::ReturnCode subEvaluate(mcsv1Context* context, const UserData* valIn);
virtual mcsv1_UDAF::ReturnCode evaluate(mcsv1Context* context, static_any::any& valOut);
virtual mcsv1_UDAF::ReturnCode dropValue(mcsv1Context* context, ColumnDatum* valsDropped);
virtual mcsv1_UDAF::ReturnCode reset(mcsv1Context* context);
virtual mcsv1_UDAF::ReturnCode nextValue(mcsv1Context* context, ColumnDatum* valsIn);
virtual mcsv1_UDAF::ReturnCode subEvaluate(mcsv1Context* context, const UserData* valIn);
virtual mcsv1_UDAF::ReturnCode evaluate(mcsv1Context* context, static_any::any& valOut);
virtual mcsv1_UDAF::ReturnCode dropValue(mcsv1Context* context, ColumnDatum* valsDropped);
// Dummy: not used
virtual mcsv1_UDAF::ReturnCode createUserData(UserData*& userData, int32_t& length)
{
return mcsv1_UDAF::SUCCESS;
}
// Dummy: not used
virtual mcsv1_UDAF::ReturnCode createUserData(UserData*& userData, int32_t& length)
{
return mcsv1_UDAF::SUCCESS;
}
};
// moda returns the modal value of the dataset. If more than one value
// have the same maximum number of occurances, then the one closest to
// AVG wins. If two are the same distance from AVG, then the smaller wins.
class moda : public mcsv1_UDAF
class moda : public mcsv1_UDAF
{
public:
// Defaults OK
moda() : mcsv1_UDAF() {};
virtual ~moda() {};
public:
// Defaults OK
moda() : mcsv1_UDAF(){};
virtual ~moda(){};
virtual mcsv1_UDAF::ReturnCode init(mcsv1Context* context,
ColumnDatum* colTypes);
virtual mcsv1_UDAF::ReturnCode init(mcsv1Context* context, ColumnDatum* colTypes);
virtual ReturnCode reset(mcsv1Context* context)
{
return getImpl(context)->reset(context);
}
virtual ReturnCode reset(mcsv1Context* context)
{
return getImpl(context)->reset(context);
}
virtual mcsv1_UDAF::ReturnCode nextValue(mcsv1Context* context, ColumnDatum* valsIn)
{
return getImpl(context)->nextValue(context, valsIn);
}
virtual mcsv1_UDAF::ReturnCode nextValue(mcsv1Context* context, ColumnDatum* valsIn)
{
return getImpl(context)->nextValue(context, valsIn);
}
virtual mcsv1_UDAF::ReturnCode subEvaluate(mcsv1Context* context, const UserData* valIn)
{
return getImpl(context)->subEvaluate(context, valIn);
}
virtual mcsv1_UDAF::ReturnCode evaluate(mcsv1Context* context, static_any::any& valOut)
{
return getImpl(context)->evaluate(context, valOut);
}
virtual mcsv1_UDAF::ReturnCode dropValue(mcsv1Context* context, ColumnDatum* valsDropped)
{
return getImpl(context)->dropValue(context, valsDropped);
}
virtual mcsv1_UDAF::ReturnCode subEvaluate(mcsv1Context* context, const UserData* valIn)
{
return getImpl(context)->subEvaluate(context, valIn);
}
mcsv1_UDAF::ReturnCode createUserData(UserData*& userData, int32_t& length)
{
userData = new ModaData;
length = sizeof(ModaData);
return mcsv1_UDAF::SUCCESS;
}
virtual mcsv1_UDAF::ReturnCode evaluate(mcsv1Context* context, static_any::any& valOut)
{
return getImpl(context)->evaluate(context, valOut);
}
mcsv1_UDAF* getImpl(mcsv1Context* context);
virtual mcsv1_UDAF::ReturnCode dropValue(mcsv1Context* context, ColumnDatum* valsDropped)
{
return getImpl(context)->dropValue(context, valsDropped);
}
protected:
Moda_impl_T<int8_t> moda_impl_int8;
Moda_impl_T<int16_t> moda_impl_int16;
Moda_impl_T<int32_t> moda_impl_int32;
Moda_impl_T<int64_t> moda_impl_int64;
Moda_impl_T<int128_t> moda_impl_int128;
Moda_impl_T<uint8_t> moda_impl_uint8;
Moda_impl_T<uint16_t> moda_impl_uint16;
Moda_impl_T<uint32_t> moda_impl_uint32;
Moda_impl_T<uint64_t> moda_impl_uint64;
Moda_impl_T<float> moda_impl_float;
Moda_impl_T<double> moda_impl_double;
Moda_impl_T<long double> moda_impl_longdouble;
mcsv1_UDAF::ReturnCode createUserData(UserData*& userData, int32_t& length)
{
userData = new ModaData;
length = sizeof(ModaData);
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF* getImpl(mcsv1Context* context);
protected:
Moda_impl_T<int8_t> moda_impl_int8;
Moda_impl_T<int16_t> moda_impl_int16;
Moda_impl_T<int32_t> moda_impl_int32;
Moda_impl_T<int64_t> moda_impl_int64;
Moda_impl_T<int128_t> moda_impl_int128;
Moda_impl_T<uint8_t> moda_impl_uint8;
Moda_impl_T<uint16_t> moda_impl_uint16;
Moda_impl_T<uint32_t> moda_impl_uint32;
Moda_impl_T<uint64_t> moda_impl_uint64;
Moda_impl_T<float> moda_impl_float;
Moda_impl_T<double> moda_impl_double;
Moda_impl_T<long double> moda_impl_longdouble;
};
}; // namespace
}; // namespace mcsv1sdk
#undef EXPORT

271
utils/regr/modamysql.cpp
View File

@ -12,90 +12,88 @@ namespace
{
inline bool isNumeric(int type, const char* attr)
{
if (type == INT_RESULT || type == REAL_RESULT || type == DECIMAL_RESULT)
{
return true;
}
if (type == INT_RESULT || type == REAL_RESULT || type == DECIMAL_RESULT)
{
return true;
}
#if _MSC_VER
if (_strnicmp("NULL", attr, 4) == 0))
if (_strnicmp("NULL", attr, 4) == 0))
#else
if (strncasecmp("NULL", attr, 4) == 0)
if (strncasecmp("NULL", attr, 4) == 0)
#endif
{
return true;
return true;
}
return false;
return false;
}
struct moda_data
{
long double fSum;
uint64_t fCount;
enum Item_result fReturnType;
std::unordered_map<int64_t, uint32_t> mapINT;
std::unordered_map<double, uint32_t> mapREAL;
std::unordered_map<long double, uint32_t> mapDECIMAL;
std::string result;
void clear()
{
fSum = 0.0;
fCount = 0;
mapINT.clear();
mapREAL.clear();
mapDECIMAL.clear();
}
long double fSum;
uint64_t fCount;
enum Item_result fReturnType;
std::unordered_map<int64_t, uint32_t> mapINT;
std::unordered_map<double, uint32_t> mapREAL;
std::unordered_map<long double, uint32_t> mapDECIMAL;
std::string result;
void clear()
{
fSum = 0.0;
fCount = 0;
mapINT.clear();
mapREAL.clear();
mapDECIMAL.clear();
}
};
}
} // namespace
template<class TYPE, class CONTAINER>
char * moda(CONTAINER & container, struct moda_data* data)
template <class TYPE, class CONTAINER>
char* moda(CONTAINER& container, struct moda_data* data)
{
TYPE avg = (TYPE)data->fCount ? data->fSum / data->fCount : 0;
TYPE val = 0.0;
uint32_t maxCnt = 0.0;
TYPE avg = (TYPE)data->fCount ? data->fSum / data->fCount : 0;
TYPE val = 0.0;
uint32_t maxCnt = 0.0;
for (auto iter = container.begin(); iter != container.end(); ++iter)
for (auto iter = container.begin(); iter != container.end(); ++iter)
{
if (iter->second > maxCnt)
{
if (iter->second > maxCnt)
{
val = iter->first;
maxCnt = iter->second;
}
else if (iter->second == maxCnt)
{
// Tie breaker: choose the closest to avg. If still tie, choose smallest
if ((abs(val-avg) > abs(iter->first-avg))
|| ((abs(val-avg) == abs(iter->first-avg)) && (abs(val) > abs(iter->first))))
{
val = iter->first;
}
}
val = iter->first;
maxCnt = iter->second;
}
else if (iter->second == maxCnt)
{
// Tie breaker: choose the closest to avg. If still tie, choose smallest
if ((abs(val - avg) > abs(iter->first - avg)) ||
((abs(val - avg) == abs(iter->first - avg)) && (abs(val) > abs(iter->first))))
{
val = iter->first;
}
}
}
data->result = std::to_string(val);
data->result = std::to_string(val);
return const_cast<char*>(data->result.c_str());
return const_cast<char*>(data->result.c_str());
}
extern "C"
{
#ifdef _MSC_VER
__declspec(dllexport)
__declspec(dllexport)
#endif
my_bool moda_init(UDF_INIT* initid, UDF_ARGS* args, char* message)
{
my_bool moda_init(UDF_INIT* initid, UDF_ARGS* args, char* message)
{
struct moda_data* data;
if (args->arg_count != 1)
{
strcpy(message,"moda() requires one argument");
return 1;
strcpy(message, "moda() requires one argument");
return 1;
}
if (!isNumeric(args->arg_type[0], args->attributes[0]))
{
strcpy(message,"moda() with a non-numeric argument");
return 1;
strcpy(message, "moda() with a non-numeric argument");
return 1;
}
data = new moda_data;
@ -104,40 +102,37 @@ my_bool moda_init(UDF_INIT* initid, UDF_ARGS* args, char* message)
data->fSum = 0.0;
initid->ptr = (char*)data;
return 0;
}
}
#ifdef _MSC_VER
__declspec(dllexport)
__declspec(dllexport)
#endif
void moda_deinit(UDF_INIT* initid)
{
void moda_deinit(UDF_INIT* initid)
{
struct moda_data* data = (struct moda_data*)initid->ptr;
data->clear();
delete data;
}
}
#ifdef _MSC_VER
__declspec(dllexport)
__declspec(dllexport)
#endif
void moda_clear(UDF_INIT* initid, char* is_null __attribute__((unused)),
char* message __attribute__((unused)))
{
void moda_clear(UDF_INIT* initid, char* is_null __attribute__((unused)),
char* message __attribute__((unused)))
{
struct moda_data* data = (struct moda_data*)initid->ptr;
data->clear();
}
}
#ifdef _MSC_VER
__declspec(dllexport)
__declspec(dllexport)
#endif
void moda_add(UDF_INIT* initid,
UDF_ARGS* args,
char* is_null,
char* message __attribute__((unused)))
{
void moda_add(UDF_INIT* initid, UDF_ARGS* args, char* is_null, char* message __attribute__((unused)))
{
// Test for NULL
if (args->args[0] == 0)
{
return;
return;
}
struct moda_data* data = (struct moda_data*)initid->ptr;
@ -145,96 +140,88 @@ void moda_add(UDF_INIT* initid,
switch (args->arg_type[0])
{
case INT_RESULT:
{
int64_t val = *((int64_t*)args->args[0]);
data->fSum += (long double)val;
data->mapINT[val]++;
break;
}
case REAL_RESULT:
{
double val = *((double*)args->args[0]);
data->fSum += val;
data->mapREAL[val]++;
break;
}
case DECIMAL_RESULT:
case STRING_RESULT:
{
long double val = strtold(args->args[0], 0);
data->fSum += val;
data->mapDECIMAL[val]++;
break;
}
default:
break;
case INT_RESULT:
{
int64_t val = *((int64_t*)args->args[0]);
data->fSum += (long double)val;
data->mapINT[val]++;
break;
}
case REAL_RESULT:
{
double val = *((double*)args->args[0]);
data->fSum += val;
data->mapREAL[val]++;
break;
}
case DECIMAL_RESULT:
case STRING_RESULT:
{
long double val = strtold(args->args[0], 0);
data->fSum += val;
data->mapDECIMAL[val]++;
break;
}
default: break;
}
}
}
#ifdef _MSC_VER
__declspec(dllexport)
__declspec(dllexport)
#endif
void moda_remove(UDF_INIT* initid, UDF_ARGS* args,
char* is_null,
char* message __attribute__((unused)))
{
void moda_remove(UDF_INIT* initid, UDF_ARGS* args, char* is_null, char* message __attribute__((unused)))
{
// Test for NULL
if (args->args[0] == 0)
{
return;
return;
}
struct moda_data* data = (struct moda_data*)initid->ptr;
data->fCount--;
switch (args->arg_type[0])
{
case INT_RESULT:
{
int64_t val = *((int64_t*)args->args[0]);
data->fSum -= (long double)val;
data->mapINT[val]--;
break;
}
case REAL_RESULT:
{
double val = *((double*)args->args[0]);
data->fSum -= val;
data->mapREAL[val]--;
break;
}
case DECIMAL_RESULT:
case STRING_RESULT:
{
long double val = strtold(args->args[0], 0);
data->fSum -= val;
data->mapDECIMAL[val]--;
break;
}
default:
break;
case INT_RESULT:
{
int64_t val = *((int64_t*)args->args[0]);
data->fSum -= (long double)val;
data->mapINT[val]--;
break;
}
case REAL_RESULT:
{
double val = *((double*)args->args[0]);
data->fSum -= val;
data->mapREAL[val]--;
break;
}
case DECIMAL_RESULT:
case STRING_RESULT:
{
long double val = strtold(args->args[0], 0);
data->fSum -= val;
data->mapDECIMAL[val]--;
break;
}
default: break;
}
}
}
#ifdef _MSC_VER
__declspec(dllexport)
__declspec(dllexport)
#endif
char* moda(UDF_INIT* initid, UDF_ARGS* args, char* is_null, char* error __attribute__((unused)))
{
char* moda(UDF_INIT* initid, UDF_ARGS* args, char* is_null, char* error __attribute__((unused)))
{
struct moda_data* data = (struct moda_data*)initid->ptr;
switch (args->arg_type[0])
{
case INT_RESULT:
return moda<int64_t>(data->mapINT, data);
case REAL_RESULT:
return moda<double>(data->mapREAL, data);
case DECIMAL_RESULT:
case STRING_RESULT:
return moda<long double>(data->mapDECIMAL, data);
default:
return NULL;
case INT_RESULT: return moda<int64_t>(data->mapINT, data);
case REAL_RESULT: return moda<double>(data->mapREAL, data);
case DECIMAL_RESULT:
case STRING_RESULT: return moda<long double>(data->mapDECIMAL, data);
default: return NULL;
}
return NULL;
}
} // Extern "C"
}
} // Extern "C"

128
utils/regr/regr_avgx.cpp
View File

@ -26,11 +26,11 @@ using namespace mcsv1sdk;
class Add_regr_avgx_ToUDAFMap
{
public:
Add_regr_avgx_ToUDAFMap()
{
UDAFMap::getMap()["regr_avgx"] = new regr_avgx();
}
public:
Add_regr_avgx_ToUDAFMap()
{
UDAFMap::getMap()["regr_avgx"] = new regr_avgx();
}
};
static Add_regr_avgx_ToUDAFMap addToMap;
@ -40,97 +40,93 @@ static Add_regr_avgx_ToUDAFMap addToMap;
// Use the simple data model
struct regr_avgx_data
{
long double sum;
uint64_t cnt;
long double sum;
uint64_t cnt;
};
mcsv1_UDAF::ReturnCode regr_avgx::init(mcsv1Context* context,
ColumnDatum* colTypes)
mcsv1_UDAF::ReturnCode regr_avgx::init(mcsv1Context* context, ColumnDatum* colTypes)
{
if (context->getParameterCount() != 2)
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("regr_avgx() with other than 2 arguments");
return mcsv1_UDAF::ERROR;
}
if (context->getParameterCount() != 2)
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("regr_avgx() with other than 2 arguments");
return mcsv1_UDAF::ERROR;
}
if (!(isNumeric(colTypes[1].dataType)))
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("regr_avgx() with a non-numeric x argument");
return mcsv1_UDAF::ERROR;
}
context->setUserDataSize(sizeof(regr_avgx_data));
context->setResultType(execplan::CalpontSystemCatalog::DOUBLE);
context->setColWidth(8);
context->setScale(colTypes[1].scale + 4);
context->setPrecision(19);
context->setRunFlag(mcsv1sdk::UDAF_IGNORE_NULLS);
return mcsv1_UDAF::SUCCESS;
if (!(isNumeric(colTypes[1].dataType)))
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("regr_avgx() with a non-numeric x argument");
return mcsv1_UDAF::ERROR;
}
context->setUserDataSize(sizeof(regr_avgx_data));
context->setResultType(execplan::CalpontSystemCatalog::DOUBLE);
context->setColWidth(8);
context->setScale(colTypes[1].scale + 4);
context->setPrecision(19);
context->setRunFlag(mcsv1sdk::UDAF_IGNORE_NULLS);
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_avgx::reset(mcsv1Context* context)
{
struct regr_avgx_data* data = (struct regr_avgx_data*)context->getUserData()->data;
data->sum = 0;
data->cnt = 0;
return mcsv1_UDAF::SUCCESS;
struct regr_avgx_data* data = (struct regr_avgx_data*)context->getUserData()->data;
data->sum = 0;
data->cnt = 0;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_avgx::nextValue(mcsv1Context* context, ColumnDatum* valsIn)
{
DATATYPE val = toDouble(valsIn[1]);
struct regr_avgx_data* data = (struct regr_avgx_data*)context->getUserData()->data;
DATATYPE val = toDouble(valsIn[1]);
struct regr_avgx_data* data = (struct regr_avgx_data*)context->getUserData()->data;
data->sum += val;
++data->cnt;
data->sum += val;
++data->cnt;
return mcsv1_UDAF::SUCCESS;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_avgx::subEvaluate(mcsv1Context* context, const UserData* userDataIn)
{
if (!userDataIn)
{
return mcsv1_UDAF::SUCCESS;
}
struct regr_avgx_data* outData = (struct regr_avgx_data*)context->getUserData()->data;
struct regr_avgx_data* inData = (struct regr_avgx_data*)userDataIn->data;
outData->sum += inData->sum;
outData->cnt += inData->cnt;
if (!userDataIn)
{
return mcsv1_UDAF::SUCCESS;
}
struct regr_avgx_data* outData = (struct regr_avgx_data*)context->getUserData()->data;
struct regr_avgx_data* inData = (struct regr_avgx_data*)userDataIn->data;
outData->sum += inData->sum;
outData->cnt += inData->cnt;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_avgx::evaluate(mcsv1Context* context, static_any::any& valOut)
{
struct regr_avgx_data* data = (struct regr_avgx_data*)context->getUserData()->data;
struct regr_avgx_data* data = (struct regr_avgx_data*)context->getUserData()->data;
if (data->cnt > 0)
{
valOut = static_cast<double>(data->sum / (long double)data->cnt);
}
if (data->cnt > 0)
{
valOut = static_cast<double>(data->sum / (long double)data->cnt);
}
return mcsv1_UDAF::SUCCESS;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_avgx::dropValue(mcsv1Context* context, ColumnDatum* valsDropped)
{
double val = toDouble(valsDropped[1]);
struct regr_avgx_data* data = (struct regr_avgx_data*)context->getUserData()->data;
double val = toDouble(valsDropped[1]);
struct regr_avgx_data* data = (struct regr_avgx_data*)context->getUserData()->data;
data->sum -= val;
--data->cnt;
data->sum -= val;
--data->cnt;
return mcsv1_UDAF::SUCCESS;
return mcsv1_UDAF::SUCCESS;
}

38
utils/regr/regr_avgx.h
View File

@ -16,10 +16,10 @@
MA 02110-1301, USA. */
/***********************************************************************
* $Id$
*
* regr_avgx.h
***********************************************************************/
* $Id$
*
* regr_avgx.h
***********************************************************************/
/**
* Columnstore interface for for the regr_avgx function
@ -51,7 +51,6 @@
namespace mcsv1sdk
{
// Override mcsv1_UDAF to build your User Defined Aggregate (UDAF) and/or
// User Defined Analytic Function (UDAnF).
// These will be singleton classes, so don't put any instance
@ -64,31 +63,28 @@ namespace mcsv1sdk
// Return the regr_avgx value of the dataset
class regr_avgx : public mcsv1_UDAF
class regr_avgx : public mcsv1_UDAF
{
public:
// Defaults OK
regr_avgx() : mcsv1_UDAF() {};
virtual ~regr_avgx() {};
public:
// Defaults OK
regr_avgx() : mcsv1_UDAF(){};
virtual ~regr_avgx(){};
virtual ReturnCode init(mcsv1Context* context,
ColumnDatum* colTypes);
virtual ReturnCode init(mcsv1Context* context, ColumnDatum* colTypes);
virtual ReturnCode reset(mcsv1Context* context);
virtual ReturnCode reset(mcsv1Context* context);
virtual ReturnCode nextValue(mcsv1Context* context, ColumnDatum* valsIn);
virtual ReturnCode nextValue(mcsv1Context* context, ColumnDatum* valsIn);
virtual ReturnCode subEvaluate(mcsv1Context* context, const UserData* valIn);
virtual ReturnCode subEvaluate(mcsv1Context* context, const UserData* valIn);
virtual ReturnCode evaluate(mcsv1Context* context, static_any::any& valOut);
virtual ReturnCode evaluate(mcsv1Context* context, static_any::any& valOut);
virtual ReturnCode dropValue(mcsv1Context* context, ColumnDatum* valsDropped);
virtual ReturnCode dropValue(mcsv1Context* context, ColumnDatum* valsDropped);
protected:
protected:
};
}; // namespace
}; // namespace mcsv1sdk
#undef EXPORT

124
utils/regr/regr_avgy.cpp
View File

@ -26,11 +26,11 @@ using namespace mcsv1sdk;
class Add_regr_avgy_ToUDAFMap
{
public:
Add_regr_avgy_ToUDAFMap()
{
UDAFMap::getMap()["regr_avgy"] = new regr_avgy();
}
public:
Add_regr_avgy_ToUDAFMap()
{
UDAFMap::getMap()["regr_avgy"] = new regr_avgy();
}
};
static Add_regr_avgy_ToUDAFMap addToMap;
@ -40,94 +40,90 @@ static Add_regr_avgy_ToUDAFMap addToMap;
// Use the simple data model
struct regr_avgy_data
{
long double sum;
uint64_t cnt;
long double sum;
uint64_t cnt;
};
mcsv1_UDAF::ReturnCode regr_avgy::init(mcsv1Context* context,
ColumnDatum* colTypes)
mcsv1_UDAF::ReturnCode regr_avgy::init(mcsv1Context* context, ColumnDatum* colTypes)
{
if (context->getParameterCount() != 2)
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("regr_avgy() with other than 2 arguments");
return mcsv1_UDAF::ERROR;
}
if (context->getParameterCount() != 2)
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("regr_avgy() with other than 2 arguments");
return mcsv1_UDAF::ERROR;
}
if (!(isNumeric(colTypes[0].dataType)))
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("regr_avgy() with a non-numeric y argument");
return mcsv1_UDAF::ERROR;
}
context->setUserDataSize(sizeof(regr_avgy_data));
context->setResultType(execplan::CalpontSystemCatalog::DOUBLE);
context->setColWidth(8);
context->setScale(colTypes[0].scale + 4);
context->setPrecision(19);
context->setRunFlag(mcsv1sdk::UDAF_IGNORE_NULLS);
return mcsv1_UDAF::SUCCESS;
if (!(isNumeric(colTypes[0].dataType)))
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("regr_avgy() with a non-numeric y argument");
return mcsv1_UDAF::ERROR;
}
context->setUserDataSize(sizeof(regr_avgy_data));
context->setResultType(execplan::CalpontSystemCatalog::DOUBLE);
context->setColWidth(8);
context->setScale(colTypes[0].scale + 4);
context->setPrecision(19);
context->setRunFlag(mcsv1sdk::UDAF_IGNORE_NULLS);
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_avgy::reset(mcsv1Context* context)
{
struct regr_avgy_data* data = (struct regr_avgy_data*)context->getUserData()->data;
data->sum = 0;
data->cnt = 0;
return mcsv1_UDAF::SUCCESS;
struct regr_avgy_data* data = (struct regr_avgy_data*)context->getUserData()->data;
data->sum = 0;
data->cnt = 0;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_avgy::nextValue(mcsv1Context* context, ColumnDatum* valsIn)
{
double val = toDouble(valsIn[0]);
struct regr_avgy_data* data = (struct regr_avgy_data*)context->getUserData()->data;
double val = toDouble(valsIn[0]);
struct regr_avgy_data* data = (struct regr_avgy_data*)context->getUserData()->data;
data->sum += val;
++data->cnt;
data->sum += val;
++data->cnt;
return mcsv1_UDAF::SUCCESS;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_avgy::subEvaluate(mcsv1Context* context, const UserData* userDataIn)
{
if (!userDataIn)
{
return mcsv1_UDAF::SUCCESS;
}
struct regr_avgy_data* outData = (struct regr_avgy_data*)context->getUserData()->data;
struct regr_avgy_data* inData = (struct regr_avgy_data*)userDataIn->data;
outData->sum += inData->sum;
outData->cnt += inData->cnt;
if (!userDataIn)
{
return mcsv1_UDAF::SUCCESS;
}
struct regr_avgy_data* outData = (struct regr_avgy_data*)context->getUserData()->data;
struct regr_avgy_data* inData = (struct regr_avgy_data*)userDataIn->data;
outData->sum += inData->sum;
outData->cnt += inData->cnt;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_avgy::evaluate(mcsv1Context* context, static_any::any& valOut)
{
struct regr_avgy_data* data = (struct regr_avgy_data*)context->getUserData()->data;
struct regr_avgy_data* data = (struct regr_avgy_data*)context->getUserData()->data;
if (data->cnt > 0)
{
valOut = static_cast<double>(data->sum / (long double)data->cnt);
}
return mcsv1_UDAF::SUCCESS;
if (data->cnt > 0)
{
valOut = static_cast<double>(data->sum / (long double)data->cnt);
}
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_avgy::dropValue(mcsv1Context* context, ColumnDatum* valsDropped)
{
double val = toDouble(valsDropped[0]);
struct regr_avgy_data* data = (struct regr_avgy_data*)context->getUserData()->data;
double val = toDouble(valsDropped[0]);
struct regr_avgy_data* data = (struct regr_avgy_data*)context->getUserData()->data;
data->sum -= val;
--data->cnt;
data->sum -= val;
--data->cnt;
return mcsv1_UDAF::SUCCESS;
return mcsv1_UDAF::SUCCESS;
}

38
utils/regr/regr_avgy.h
View File

@ -16,10 +16,10 @@
MA 02110-1301, USA. */
/***********************************************************************
* $Id$
*
* regr_avgy.h
***********************************************************************/
* $Id$
*
* regr_avgy.h
***********************************************************************/
/**
* Columnstore interface for for the regr_avgy function
@ -51,34 +51,30 @@
namespace mcsv1sdk
{
// Return the regr_avgy value of the dataset
class regr_avgy : public mcsv1_UDAF
class regr_avgy : public mcsv1_UDAF
{
public:
// Defaults OK
regr_avgy() : mcsv1_UDAF() {};
virtual ~regr_avgy() {};
public:
// Defaults OK
regr_avgy() : mcsv1_UDAF(){};
virtual ~regr_avgy(){};
virtual ReturnCode init(mcsv1Context* context,
ColumnDatum* colTypes);
virtual ReturnCode init(mcsv1Context* context, ColumnDatum* colTypes);
virtual ReturnCode reset(mcsv1Context* context);
virtual ReturnCode reset(mcsv1Context* context);
virtual ReturnCode nextValue(mcsv1Context* context, ColumnDatum* valsIn);
virtual ReturnCode nextValue(mcsv1Context* context, ColumnDatum* valsIn);
virtual ReturnCode subEvaluate(mcsv1Context* context, const UserData* valIn);
virtual ReturnCode subEvaluate(mcsv1Context* context, const UserData* valIn);
virtual ReturnCode evaluate(mcsv1Context* context, static_any::any& valOut);
virtual ReturnCode evaluate(mcsv1Context* context, static_any::any& valOut);
virtual ReturnCode dropValue(mcsv1Context* context, ColumnDatum* valsDropped);
virtual ReturnCode dropValue(mcsv1Context* context, ColumnDatum* valsDropped);
protected:
protected:
};
}; // namespace
}; // namespace mcsv1sdk
#undef EXPORT

126
utils/regr/regr_count.cpp
View File

@ -26,11 +26,11 @@ using namespace mcsv1sdk;
class Add_regr_count_ToUDAFMap
{
public:
Add_regr_count_ToUDAFMap()
{
UDAFMap::getMap()["regr_count"] = new regr_count();
}
public:
Add_regr_count_ToUDAFMap()
{
UDAFMap::getMap()["regr_count"] = new regr_count();
}
};
static Add_regr_count_ToUDAFMap addToMap;
@ -38,94 +38,90 @@ static Add_regr_count_ToUDAFMap addToMap;
// Use the simple data model
struct regr_count_data
{
long long cnt;
long long cnt;
};
mcsv1_UDAF::ReturnCode regr_count::init(mcsv1Context* context,
ColumnDatum* colTypes)
mcsv1_UDAF::ReturnCode regr_count::init(mcsv1Context* context, ColumnDatum* colTypes)
{
if (context->getParameterCount() != 2)
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("regr_count() with other than 2 arguments");
return mcsv1_UDAF::ERROR;
}
context->setUserDataSize(sizeof(regr_count_data));
context->setResultType(execplan::CalpontSystemCatalog::BIGINT);
context->setColWidth(8);
context->setRunFlag(mcsv1sdk::UDAF_IGNORE_NULLS);
return mcsv1_UDAF::SUCCESS;
if (context->getParameterCount() != 2)
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("regr_count() with other than 2 arguments");
return mcsv1_UDAF::ERROR;
}
context->setUserDataSize(sizeof(regr_count_data));
context->setResultType(execplan::CalpontSystemCatalog::BIGINT);
context->setColWidth(8);
context->setRunFlag(mcsv1sdk::UDAF_IGNORE_NULLS);
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_count::reset(mcsv1Context* context)
{
struct regr_count_data* data = (struct regr_count_data*)context->getUserData()->data;
data->cnt = 0;
return mcsv1_UDAF::SUCCESS;
struct regr_count_data* data = (struct regr_count_data*)context->getUserData()->data;
data->cnt = 0;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_count::nextValue(mcsv1Context* context, ColumnDatum* valsIn)
{
static_any::any& valIn_y = valsIn[0].columnData;
static_any::any& valIn_x = valsIn[1].columnData;
struct regr_count_data* data = (struct regr_count_data*)context->getUserData()->data;
static_any::any& valIn_y = valsIn[0].columnData;
static_any::any& valIn_x = valsIn[1].columnData;
struct regr_count_data* data = (struct regr_count_data*)context->getUserData()->data;
if (context->isParamNull(0) || context->isParamNull(1))
{
return mcsv1_UDAF::SUCCESS; // Ought not happen when UDAF_IGNORE_NULLS is on.
}
if (valIn_x.empty() || valIn_y.empty()) // Usually empty if NULL. Probably redundant
{
return mcsv1_UDAF::SUCCESS; // Ought not happen when UDAF_IGNORE_NULLS is on.
}
++data->cnt;
if (context->isParamNull(0) || context->isParamNull(1))
{
return mcsv1_UDAF::SUCCESS; // Ought not happen when UDAF_IGNORE_NULLS is on.
}
if (valIn_x.empty() || valIn_y.empty()) // Usually empty if NULL. Probably redundant
{
return mcsv1_UDAF::SUCCESS; // Ought not happen when UDAF_IGNORE_NULLS is on.
}
++data->cnt;
return mcsv1_UDAF::SUCCESS;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_count::subEvaluate(mcsv1Context* context, const UserData* userDataIn)
{
if (!userDataIn)
{
return mcsv1_UDAF::SUCCESS;
}
struct regr_count_data* outData = (struct regr_count_data*)context->getUserData()->data;
struct regr_count_data* inData = (struct regr_count_data*)userDataIn->data;
outData->cnt += inData->cnt;
if (!userDataIn)
{
return mcsv1_UDAF::SUCCESS;
}
struct regr_count_data* outData = (struct regr_count_data*)context->getUserData()->data;
struct regr_count_data* inData = (struct regr_count_data*)userDataIn->data;
outData->cnt += inData->cnt;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_count::evaluate(mcsv1Context* context, static_any::any& valOut)
{
struct regr_count_data* data = (struct regr_count_data*)context->getUserData()->data;
struct regr_count_data* data = (struct regr_count_data*)context->getUserData()->data;
valOut = data->cnt;
return mcsv1_UDAF::SUCCESS;
valOut = data->cnt;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_count::dropValue(mcsv1Context* context, ColumnDatum* valsDropped)
{
static_any::any& valIn_y = valsDropped[0].columnData;
static_any::any& valIn_x = valsDropped[1].columnData;
struct regr_count_data* data = (struct regr_count_data*)context->getUserData()->data;
static_any::any& valIn_y = valsDropped[0].columnData;
static_any::any& valIn_x = valsDropped[1].columnData;
struct regr_count_data* data = (struct regr_count_data*)context->getUserData()->data;
if (context->isParamNull(0) || context->isParamNull(1))
{
return mcsv1_UDAF::SUCCESS; // Ought not happen when UDAF_IGNORE_NULLS is on.
}
if (valIn_x.empty() || valIn_y.empty())
{
return mcsv1_UDAF::SUCCESS; // Ought not happen when UDAF_IGNORE_NULLS is on.
}
--data->cnt;
if (context->isParamNull(0) || context->isParamNull(1))
{
return mcsv1_UDAF::SUCCESS; // Ought not happen when UDAF_IGNORE_NULLS is on.
}
if (valIn_x.empty() || valIn_y.empty())
{
return mcsv1_UDAF::SUCCESS; // Ought not happen when UDAF_IGNORE_NULLS is on.
}
--data->cnt;
return mcsv1_UDAF::SUCCESS;
return mcsv1_UDAF::SUCCESS;
}

38
utils/regr/regr_count.h
View File

@ -16,10 +16,10 @@
MA 02110-1301, USA. */
/***********************************************************************
* $Id$
*
* regr_count.h
***********************************************************************/
* $Id$
*
* regr_count.h
***********************************************************************/
/**
* Columnstore interface for for the regr_count function
@ -51,34 +51,30 @@
namespace mcsv1sdk
{
// Return the regr_count value of the dataset
class regr_count : public mcsv1_UDAF
class regr_count : public mcsv1_UDAF
{
public:
// Defaults OK
regr_count() : mcsv1_UDAF() {};
virtual ~regr_count() {};
public:
// Defaults OK
regr_count() : mcsv1_UDAF(){};
virtual ~regr_count(){};
virtual ReturnCode init(mcsv1Context* context,
ColumnDatum* colTypes);
virtual ReturnCode init(mcsv1Context* context, ColumnDatum* colTypes);
virtual ReturnCode reset(mcsv1Context* context);
virtual ReturnCode reset(mcsv1Context* context);
virtual ReturnCode nextValue(mcsv1Context* context, ColumnDatum* valsIn);
virtual ReturnCode nextValue(mcsv1Context* context, ColumnDatum* valsIn);
virtual ReturnCode subEvaluate(mcsv1Context* context, const UserData* valIn);
virtual ReturnCode subEvaluate(mcsv1Context* context, const UserData* valIn);
virtual ReturnCode evaluate(mcsv1Context* context, static_any::any& valOut);
virtual ReturnCode evaluate(mcsv1Context* context, static_any::any& valOut);
virtual ReturnCode dropValue(mcsv1Context* context, ColumnDatum* valsDropped);
virtual ReturnCode dropValue(mcsv1Context* context, ColumnDatum* valsDropped);
protected:
protected:
};
}; // namespace
}; // namespace mcsv1sdk
#undef EXPORT

181
utils/regr/regr_intercept.cpp
View File

@ -26,11 +26,11 @@ using namespace mcsv1sdk;
class Add_regr_intercept_ToUDAFMap
{
public:
Add_regr_intercept_ToUDAFMap()
{
UDAFMap::getMap()["regr_intercept"] = new regr_intercept();
}
public:
Add_regr_intercept_ToUDAFMap()
{
UDAFMap::getMap()["regr_intercept"] = new regr_intercept();
}
};
static Add_regr_intercept_ToUDAFMap addToMap;
@ -38,123 +38,120 @@ static Add_regr_intercept_ToUDAFMap addToMap;
// Use the simple data model
struct regr_intercept_data
{
uint64_t cnt;
long double sumx;
long double sumx2; // sum of (x squared)
long double sumy;
long double sumxy; // sum of x * y
uint64_t cnt;
long double sumx;
long double sumx2; // sum of (x squared)
long double sumy;
long double sumxy; // sum of x * y
};
mcsv1_UDAF::ReturnCode regr_intercept::init(mcsv1Context* context,
ColumnDatum* colTypes)
mcsv1_UDAF::ReturnCode regr_intercept::init(mcsv1Context* context, ColumnDatum* colTypes)
{
if (context->getParameterCount() != 2)
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("regr_intercept() with other than 2 arguments");
return mcsv1_UDAF::ERROR;
}
if (!(isNumeric(colTypes[0].dataType) && isNumeric(colTypes[1].dataType)))
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("regr_intercept() with non-numeric arguments");
return mcsv1_UDAF::ERROR;
}
context->setUserDataSize(sizeof(regr_intercept_data));
context->setResultType(execplan::CalpontSystemCatalog::DOUBLE);
context->setColWidth(8);
context->setScale(DECIMAL_NOT_SPECIFIED);
context->setPrecision(0);
context->setRunFlag(mcsv1sdk::UDAF_IGNORE_NULLS);
return mcsv1_UDAF::SUCCESS;
if (context->getParameterCount() != 2)
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("regr_intercept() with other than 2 arguments");
return mcsv1_UDAF::ERROR;
}
if (!(isNumeric(colTypes[0].dataType) && isNumeric(colTypes[1].dataType)))
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("regr_intercept() with non-numeric arguments");
return mcsv1_UDAF::ERROR;
}
context->setUserDataSize(sizeof(regr_intercept_data));
context->setResultType(execplan::CalpontSystemCatalog::DOUBLE);
context->setColWidth(8);
context->setScale(DECIMAL_NOT_SPECIFIED);
context->setPrecision(0);
context->setRunFlag(mcsv1sdk::UDAF_IGNORE_NULLS);
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_intercept::reset(mcsv1Context* context)
{
struct regr_intercept_data* data = (struct regr_intercept_data*)context->getUserData()->data;
data->cnt = 0;
data->sumx = 0.0;
data->sumx2 = 0.0;
data->sumy = 0.0;
data->sumxy = 0.0;
return mcsv1_UDAF::SUCCESS;
struct regr_intercept_data* data = (struct regr_intercept_data*)context->getUserData()->data;
data->cnt = 0;
data->sumx = 0.0;
data->sumx2 = 0.0;
data->sumy = 0.0;
data->sumxy = 0.0;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_intercept::nextValue(mcsv1Context* context, ColumnDatum* valsIn)
{
double valy = toDouble(valsIn[0]);
double valx = toDouble(valsIn[1]);
struct regr_intercept_data* data = (struct regr_intercept_data*)context->getUserData()->data;
double valy = toDouble(valsIn[0]);
double valx = toDouble(valsIn[1]);
struct regr_intercept_data* data = (struct regr_intercept_data*)context->getUserData()->data;
data->sumy += valy;
data->sumx += valx;
data->sumx2 += valx*valx;
data->sumy += valy;
data->sumx += valx;
data->sumx2 += valx * valx;
data->sumxy += valx*valy;
++data->cnt;
return mcsv1_UDAF::SUCCESS;
data->sumxy += valx * valy;
++data->cnt;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_intercept::subEvaluate(mcsv1Context* context, const UserData* userDataIn)
{
if (!userDataIn)
{
return mcsv1_UDAF::SUCCESS;
}
struct regr_intercept_data* outData = (struct regr_intercept_data*)context->getUserData()->data;
struct regr_intercept_data* inData = (struct regr_intercept_data*)userDataIn->data;
outData->sumx += inData->sumx;
outData->sumx2 += inData->sumx2;
outData->sumy += inData->sumy;
outData->sumxy += inData->sumxy;
outData->cnt += inData->cnt;
if (!userDataIn)
{
return mcsv1_UDAF::SUCCESS;
}
struct regr_intercept_data* outData = (struct regr_intercept_data*)context->getUserData()->data;
struct regr_intercept_data* inData = (struct regr_intercept_data*)userDataIn->data;
outData->sumx += inData->sumx;
outData->sumx2 += inData->sumx2;
outData->sumy += inData->sumy;
outData->sumxy += inData->sumxy;
outData->cnt += inData->cnt;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_intercept::evaluate(mcsv1Context* context, static_any::any& valOut)
{
struct regr_intercept_data* data = (struct regr_intercept_data*)context->getUserData()->data;
long double N = data->cnt;
if (N > 1)
struct regr_intercept_data* data = (struct regr_intercept_data*)context->getUserData()->data;
long double N = data->cnt;
if (N > 1)
{
long double sumx = data->sumx;
long double sumy = data->sumy;
long double sumx2 = data->sumx2;
long double sumxy = data->sumxy;
// regr_intercept is AVG(y) - slope(y,x)*avg(x)
// We do some algebra and we can get a slightly smaller calculation
long double numerator = sumy * sumx2 - sumx * sumxy;
long double var_pop =
(N * sumx2) - (sumx * sumx); // Not realy var_pop, but sort of after some reductions
if (var_pop > 0)
{
long double sumx = data->sumx;
long double sumy = data->sumy;
long double sumx2 = data->sumx2;
long double sumxy = data->sumxy;
// regr_intercept is AVG(y) - slope(y,x)*avg(x)
// We do some algebra and we can get a slightly smaller calculation
long double numerator = sumy * sumx2 - sumx * sumxy;
long double var_pop = (N * sumx2) - (sumx * sumx); // Not realy var_pop, but sort of after some reductions
if (var_pop > 0)
{
valOut = static_cast<double>(numerator / var_pop);
}
valOut = static_cast<double>(numerator / var_pop);
}
return mcsv1_UDAF::SUCCESS;
}
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_intercept::dropValue(mcsv1Context* context, ColumnDatum* valsDropped)
{
double valy = toDouble(valsDropped[0]);
double valx = toDouble(valsDropped[1]);
struct regr_intercept_data* data = (struct regr_intercept_data*)context->getUserData()->data;
double valy = toDouble(valsDropped[0]);
double valx = toDouble(valsDropped[1]);
struct regr_intercept_data* data = (struct regr_intercept_data*)context->getUserData()->data;
data->sumy -= valy;
data->sumx -= valx;
data->sumx2 -= valx*valx;
data->sumy -= valy;
data->sumx -= valx;
data->sumx2 -= valx * valx;
data->sumxy -= valx*valy;
--data->cnt;
data->sumxy -= valx * valy;
--data->cnt;
return mcsv1_UDAF::SUCCESS;
return mcsv1_UDAF::SUCCESS;
}

38
utils/regr/regr_intercept.h
View File

@ -16,10 +16,10 @@
MA 02110-1301, USA. */
/***********************************************************************
* $Id$
*
* regr_intercept.h
***********************************************************************/
* $Id$
*
* regr_intercept.h
***********************************************************************/
/**
* Columnstore interface for for the regr_intercept function
@ -51,34 +51,30 @@
namespace mcsv1sdk
{
// Return the regr_intercept value of the dataset
class regr_intercept : public mcsv1_UDAF
class regr_intercept : public mcsv1_UDAF
{
public:
// Defaults OK
regr_intercept() : mcsv1_UDAF() {};
virtual ~regr_intercept() {};
public:
// Defaults OK
regr_intercept() : mcsv1_UDAF(){};
virtual ~regr_intercept(){};
virtual ReturnCode init(mcsv1Context* context,
ColumnDatum* colTypes);
virtual ReturnCode init(mcsv1Context* context, ColumnDatum* colTypes);
virtual ReturnCode reset(mcsv1Context* context);
virtual ReturnCode reset(mcsv1Context* context);
virtual ReturnCode nextValue(mcsv1Context* context, ColumnDatum* valsIn);
virtual ReturnCode nextValue(mcsv1Context* context, ColumnDatum* valsIn);
virtual ReturnCode subEvaluate(mcsv1Context* context, const UserData* valIn);
virtual ReturnCode subEvaluate(mcsv1Context* context, const UserData* valIn);
virtual ReturnCode evaluate(mcsv1Context* context, static_any::any& valOut);
virtual ReturnCode evaluate(mcsv1Context* context, static_any::any& valOut);
virtual ReturnCode dropValue(mcsv1Context* context, ColumnDatum* valsDropped);
virtual ReturnCode dropValue(mcsv1Context* context, ColumnDatum* valsDropped);
protected:
protected:
};
}; // namespace
}; // namespace mcsv1sdk
#undef EXPORT

214
utils/regr/regr_r2.cpp
View File

@ -26,11 +26,11 @@ using namespace mcsv1sdk;
class Add_regr_r2_ToUDAFMap
{
public:
Add_regr_r2_ToUDAFMap()
{
UDAFMap::getMap()["regr_r2"] = new regr_r2();
}
public:
Add_regr_r2_ToUDAFMap()
{
UDAFMap::getMap()["regr_r2"] = new regr_r2();
}
};
static Add_regr_r2_ToUDAFMap addToMap;
@ -38,143 +38,139 @@ static Add_regr_r2_ToUDAFMap addToMap;
// Use the simple data model
struct regr_r2_data
{
uint64_t cnt;
long double sumx;
long double sumx2; // sum of (x squared)
long double sumy;
long double sumy2; // sum of (y squared)
long double sumxy; // sum of x * y
uint64_t cnt;
long double sumx;
long double sumx2; // sum of (x squared)
long double sumy;
long double sumy2; // sum of (y squared)
long double sumxy; // sum of x * y
};
mcsv1_UDAF::ReturnCode regr_r2::init(mcsv1Context* context,
ColumnDatum* colTypes)
mcsv1_UDAF::ReturnCode regr_r2::init(mcsv1Context* context, ColumnDatum* colTypes)
{
if (context->getParameterCount() != 2)
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("regr_r2() with other than 2 arguments");
return mcsv1_UDAF::ERROR;
}
if (!(isNumeric(colTypes[0].dataType) && isNumeric(colTypes[1].dataType)))
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("regr_r2() with non-numeric arguments");
return mcsv1_UDAF::ERROR;
}
context->setUserDataSize(sizeof(regr_r2_data));
context->setResultType(execplan::CalpontSystemCatalog::DOUBLE);
context->setColWidth(8);
context->setScale(DECIMAL_NOT_SPECIFIED);
context->setPrecision(0);
context->setRunFlag(mcsv1sdk::UDAF_IGNORE_NULLS);
return mcsv1_UDAF::SUCCESS;
if (context->getParameterCount() != 2)
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("regr_r2() with other than 2 arguments");
return mcsv1_UDAF::ERROR;
}
if (!(isNumeric(colTypes[0].dataType) && isNumeric(colTypes[1].dataType)))
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("regr_r2() with non-numeric arguments");
return mcsv1_UDAF::ERROR;
}
context->setUserDataSize(sizeof(regr_r2_data));
context->setResultType(execplan::CalpontSystemCatalog::DOUBLE);
context->setColWidth(8);
context->setScale(DECIMAL_NOT_SPECIFIED);
context->setPrecision(0);
context->setRunFlag(mcsv1sdk::UDAF_IGNORE_NULLS);
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_r2::reset(mcsv1Context* context)
{
struct regr_r2_data* data = (struct regr_r2_data*)context->getUserData()->data;
data->cnt = 0;
data->sumx = 0.0;
data->sumx2 = 0.0;
data->sumy = 0.0;
data->sumy2 = 0.0;
data->sumxy = 0.0;
return mcsv1_UDAF::SUCCESS;
struct regr_r2_data* data = (struct regr_r2_data*)context->getUserData()->data;
data->cnt = 0;
data->sumx = 0.0;
data->sumx2 = 0.0;
data->sumy = 0.0;
data->sumy2 = 0.0;
data->sumxy = 0.0;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_r2::nextValue(mcsv1Context* context, ColumnDatum* valsIn)
{
double valy = toDouble(valsIn[0]);
double valx = toDouble(valsIn[1]);
struct regr_r2_data* data = (struct regr_r2_data*)context->getUserData()->data;
double valy = toDouble(valsIn[0]);
double valx = toDouble(valsIn[1]);
struct regr_r2_data* data = (struct regr_r2_data*)context->getUserData()->data;
data->sumy += valy;
data->sumy2 += valy*valy;
data->sumy += valy;
data->sumy2 += valy * valy;
data->sumx += valx;
data->sumx2 += valx*valx;
data->sumx += valx;
data->sumx2 += valx * valx;
data->sumxy += valx*valy;
data->sumxy += valx * valy;
++data->cnt;
return mcsv1_UDAF::SUCCESS;
++data->cnt;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_r2::subEvaluate(mcsv1Context* context, const UserData* userDataIn)
{
if (!userDataIn)
{
return mcsv1_UDAF::SUCCESS;
}
struct regr_r2_data* outData = (struct regr_r2_data*)context->getUserData()->data;
struct regr_r2_data* inData = (struct regr_r2_data*)userDataIn->data;
outData->sumx += inData->sumx;
outData->sumx2 += inData->sumx2;
outData->sumy += inData->sumy;
outData->sumy2 += inData->sumy2;
outData->sumxy += inData->sumxy;
outData->cnt += inData->cnt;
if (!userDataIn)
{
return mcsv1_UDAF::SUCCESS;
}
struct regr_r2_data* outData = (struct regr_r2_data*)context->getUserData()->data;
struct regr_r2_data* inData = (struct regr_r2_data*)userDataIn->data;
outData->sumx += inData->sumx;
outData->sumx2 += inData->sumx2;
outData->sumy += inData->sumy;
outData->sumy2 += inData->sumy2;
outData->sumxy += inData->sumxy;
outData->cnt += inData->cnt;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_r2::evaluate(mcsv1Context* context, static_any::any& valOut)
{
struct regr_r2_data* data = (struct regr_r2_data*)context->getUserData()->data;
double N = data->cnt;
if (N > 1)
{
long double sumx = data->sumx;
long double sumy = data->sumy;
long double sumx2 = data->sumx2;
long double sumy2 = data->sumy2;
long double sumxy = data->sumxy;
struct regr_r2_data* data = (struct regr_r2_data*)context->getUserData()->data;
double N = data->cnt;
if (N > 1)
{
long double sumx = data->sumx;
long double sumy = data->sumy;
long double sumx2 = data->sumx2;
long double sumy2 = data->sumy2;
long double sumxy = data->sumxy;
long double var_popx = (sumx2 - (sumx * sumx / N)) / N;
if (var_popx <= 0) // Catch -0
{
// When var_popx is 0, NULL is the result.
return mcsv1_UDAF::SUCCESS;
}
double var_popy = (sumy2 - (sumy * sumy / N)) / N;
if (var_popy <= 0) // Catch -0
{
// When var_popy is 0, 1 is the result
valOut = 1.0;
return mcsv1_UDAF::SUCCESS;
}
long double std_popx = sqrt(var_popx);
long double std_popy = sqrt(var_popy);
long double covar_pop = (sumxy - ((sumx * sumy) / N)) / N;
long double corr = covar_pop / (std_popy * std_popx);
valOut = static_cast<double>(corr * corr);
long double var_popx = (sumx2 - (sumx * sumx / N)) / N;
if (var_popx <= 0) // Catch -0
{
// When var_popx is 0, NULL is the result.
return mcsv1_UDAF::SUCCESS;
}
return mcsv1_UDAF::SUCCESS;
double var_popy = (sumy2 - (sumy * sumy / N)) / N;
if (var_popy <= 0) // Catch -0
{
// When var_popy is 0, 1 is the result
valOut = 1.0;
return mcsv1_UDAF::SUCCESS;
}
long double std_popx = sqrt(var_popx);
long double std_popy = sqrt(var_popy);
long double covar_pop = (sumxy - ((sumx * sumy) / N)) / N;
long double corr = covar_pop / (std_popy * std_popx);
valOut = static_cast<double>(corr * corr);
}
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_r2::dropValue(mcsv1Context* context, ColumnDatum* valsDropped)
{
double valy = toDouble(valsDropped[0]);
double valx = toDouble(valsDropped[1]);
struct regr_r2_data* data = (struct regr_r2_data*)context->getUserData()->data;
double valy = toDouble(valsDropped[0]);
double valx = toDouble(valsDropped[1]);
struct regr_r2_data* data = (struct regr_r2_data*)context->getUserData()->data;
data->sumy -= valy;
data->sumy2 -= valy*valy;
data->sumy -= valy;
data->sumy2 -= valy * valy;
data->sumx -= valx;
data->sumx2 -= valx*valx;
data->sumx -= valx;
data->sumx2 -= valx * valx;
data->sumxy -= valx*valy;
--data->cnt;
data->sumxy -= valx * valy;
--data->cnt;
return mcsv1_UDAF::SUCCESS;
return mcsv1_UDAF::SUCCESS;
}

38
utils/regr/regr_r2.h
View File

@ -16,10 +16,10 @@
MA 02110-1301, USA. */
/***********************************************************************
* $Id$
*
* regr_r2.h
***********************************************************************/
* $Id$
*
* regr_r2.h
***********************************************************************/
/**
* Columnstore interface for for the regr_r2 function
@ -51,34 +51,30 @@
namespace mcsv1sdk
{
// Return the regr_r2 value of the dataset
class regr_r2 : public mcsv1_UDAF
class regr_r2 : public mcsv1_UDAF
{
public:
// Defaults OK
regr_r2() : mcsv1_UDAF() {};
virtual ~regr_r2() {};
public:
// Defaults OK
regr_r2() : mcsv1_UDAF(){};
virtual ~regr_r2(){};
virtual ReturnCode init(mcsv1Context* context,
ColumnDatum* colTypes);
virtual ReturnCode init(mcsv1Context* context, ColumnDatum* colTypes);
virtual ReturnCode reset(mcsv1Context* context);
virtual ReturnCode reset(mcsv1Context* context);
virtual ReturnCode nextValue(mcsv1Context* context, ColumnDatum* valsIn);
virtual ReturnCode nextValue(mcsv1Context* context, ColumnDatum* valsIn);
virtual ReturnCode subEvaluate(mcsv1Context* context, const UserData* valIn);
virtual ReturnCode subEvaluate(mcsv1Context* context, const UserData* valIn);
virtual ReturnCode evaluate(mcsv1Context* context, static_any::any& valOut);
virtual ReturnCode evaluate(mcsv1Context* context, static_any::any& valOut);
virtual ReturnCode dropValue(mcsv1Context* context, ColumnDatum* valsDropped);
virtual ReturnCode dropValue(mcsv1Context* context, ColumnDatum* valsDropped);
protected:
protected:
};
}; // namespace
}; // namespace mcsv1sdk
#undef EXPORT

184
utils/regr/regr_slope.cpp
View File

@ -26,11 +26,11 @@ using namespace mcsv1sdk;
class Add_regr_slope_ToUDAFMap
{
public:
Add_regr_slope_ToUDAFMap()
{
UDAFMap::getMap()["regr_slope"] = new regr_slope();
}
public:
Add_regr_slope_ToUDAFMap()
{
UDAFMap::getMap()["regr_slope"] = new regr_slope();
}
};
static Add_regr_slope_ToUDAFMap addToMap;
@ -38,122 +38,118 @@ static Add_regr_slope_ToUDAFMap addToMap;
// Use the simple data model
struct regr_slope_data
{
uint64_t cnt;
long double sumx;
long double sumx2; // sum of (x squared)
long double sumy;
long double sumxy; // sum of x * y
uint64_t cnt;
long double sumx;
long double sumx2; // sum of (x squared)
long double sumy;
long double sumxy; // sum of x * y
};
mcsv1_UDAF::ReturnCode regr_slope::init(mcsv1Context* context,
ColumnDatum* colTypes)
mcsv1_UDAF::ReturnCode regr_slope::init(mcsv1Context* context, ColumnDatum* colTypes)
{
if (context->getParameterCount() != 2)
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("regr_slope() with other than 2 arguments");
return mcsv1_UDAF::ERROR;
}
if (!(isNumeric(colTypes[0].dataType) && isNumeric(colTypes[1].dataType)))
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("regr_slope() with non-numeric arguments");
return mcsv1_UDAF::ERROR;
}
context->setUserDataSize(sizeof(regr_slope_data));
context->setResultType(execplan::CalpontSystemCatalog::DOUBLE);
context->setColWidth(8);
context->setScale(DECIMAL_NOT_SPECIFIED);
context->setPrecision(0);
context->setRunFlag(mcsv1sdk::UDAF_IGNORE_NULLS);
return mcsv1_UDAF::SUCCESS;
if (context->getParameterCount() != 2)
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("regr_slope() with other than 2 arguments");
return mcsv1_UDAF::ERROR;
}
if (!(isNumeric(colTypes[0].dataType) && isNumeric(colTypes[1].dataType)))
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("regr_slope() with non-numeric arguments");
return mcsv1_UDAF::ERROR;
}
context->setUserDataSize(sizeof(regr_slope_data));
context->setResultType(execplan::CalpontSystemCatalog::DOUBLE);
context->setColWidth(8);
context->setScale(DECIMAL_NOT_SPECIFIED);
context->setPrecision(0);
context->setRunFlag(mcsv1sdk::UDAF_IGNORE_NULLS);
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_slope::reset(mcsv1Context* context)
{
struct regr_slope_data* data = (struct regr_slope_data*)context->getUserData()->data;
data->cnt = 0;
data->sumx = 0.0;
data->sumx2 = 0.0;
data->sumy = 0.0;
data->sumxy = 0.0;
return mcsv1_UDAF::SUCCESS;
struct regr_slope_data* data = (struct regr_slope_data*)context->getUserData()->data;
data->cnt = 0;
data->sumx = 0.0;
data->sumx2 = 0.0;
data->sumy = 0.0;
data->sumxy = 0.0;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_slope::nextValue(mcsv1Context* context, ColumnDatum* valsIn)
{
double valy = toDouble(valsIn[0]);
double valx = toDouble(valsIn[1]);
struct regr_slope_data* data = (struct regr_slope_data*)context->getUserData()->data;
double valy = toDouble(valsIn[0]);
double valx = toDouble(valsIn[1]);
struct regr_slope_data* data = (struct regr_slope_data*)context->getUserData()->data;
data->sumy += valy;
data->sumx += valx;
data->sumx2 += valx*valx;
data->sumxy += valx*valy;
++data->cnt;
return mcsv1_UDAF::SUCCESS;
data->sumy += valy;
data->sumx += valx;
data->sumx2 += valx * valx;
data->sumxy += valx * valy;
++data->cnt;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_slope::subEvaluate(mcsv1Context* context, const UserData* userDataIn)
{
if (!userDataIn)
{
return mcsv1_UDAF::SUCCESS;
}
struct regr_slope_data* outData = (struct regr_slope_data*)context->getUserData()->data;
struct regr_slope_data* inData = (struct regr_slope_data*)userDataIn->data;
outData->sumx += inData->sumx;
outData->sumx2 += inData->sumx2;
outData->sumy += inData->sumy;
outData->sumxy += inData->sumxy;
outData->cnt += inData->cnt;
if (!userDataIn)
{
return mcsv1_UDAF::SUCCESS;
}
struct regr_slope_data* outData = (struct regr_slope_data*)context->getUserData()->data;
struct regr_slope_data* inData = (struct regr_slope_data*)userDataIn->data;
outData->sumx += inData->sumx;
outData->sumx2 += inData->sumx2;
outData->sumy += inData->sumy;
outData->sumxy += inData->sumxy;
outData->cnt += inData->cnt;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_slope::evaluate(mcsv1Context* context, static_any::any& valOut)
{
struct regr_slope_data* data = (struct regr_slope_data*)context->getUserData()->data;
double N = data->cnt;
if (N > 1)
struct regr_slope_data* data = (struct regr_slope_data*)context->getUserData()->data;
double N = data->cnt;
if (N > 1)
{
// COVAR_POP(y, x) / VAR_POP(x)
long double sumx = data->sumx;
long double sumy = data->sumy;
long double sumx2 = data->sumx2;
long double sumxy = data->sumxy;
// These aren't really covar_pop and var_pop. For the purposes of this calculation
// we multiplied everything by N to reduce calc time and variance.
// It all comes out after the final divide
long double covar_pop = N * sumxy - sumx * sumy;
long double var_pop = N * sumx2 - sumx * sumx;
if (var_pop > 0)
{
// COVAR_POP(y, x) / VAR_POP(x)
long double sumx = data->sumx;
long double sumy = data->sumy;
long double sumx2 = data->sumx2;
long double sumxy = data->sumxy;
// These aren't really covar_pop and var_pop. For the purposes of this calculation
// we multiplied everything by N to reduce calc time and variance.
// It all comes out after the final divide
long double covar_pop = N * sumxy - sumx * sumy;
long double var_pop = N * sumx2 - sumx * sumx;
if (var_pop > 0)
{
valOut = static_cast<double>(covar_pop / var_pop);
}
valOut = static_cast<double>(covar_pop / var_pop);
}
return mcsv1_UDAF::SUCCESS;
}
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_slope::dropValue(mcsv1Context* context, ColumnDatum* valsDropped)
{
double valy = toDouble(valsDropped[0]);
double valx = toDouble(valsDropped[1]);
struct regr_slope_data* data = (struct regr_slope_data*)context->getUserData()->data;
double valy = toDouble(valsDropped[0]);
double valx = toDouble(valsDropped[1]);
struct regr_slope_data* data = (struct regr_slope_data*)context->getUserData()->data;
data->sumy -= valy;
data->sumx -= valx;
data->sumx2 -= valx*valx;
data->sumxy -= valx*valy;
--data->cnt;
data->sumy -= valy;
data->sumx -= valx;
data->sumx2 -= valx * valx;
data->sumxy -= valx * valy;
--data->cnt;
return mcsv1_UDAF::SUCCESS;
return mcsv1_UDAF::SUCCESS;
}

38
utils/regr/regr_slope.h
View File

@ -16,10 +16,10 @@
MA 02110-1301, USA. */
/***********************************************************************
* $Id$
*
* regr_slope.h
***********************************************************************/
* $Id$
*
* regr_slope.h
***********************************************************************/
/**
* Columnstore interface for for the regr_slope function
@ -51,34 +51,30 @@
namespace mcsv1sdk
{
// Return the regr_slope value of the dataset
class regr_slope : public mcsv1_UDAF
class regr_slope : public mcsv1_UDAF
{
public:
// Defaults OK
regr_slope() : mcsv1_UDAF() {};
virtual ~regr_slope() {};
public:
// Defaults OK
regr_slope() : mcsv1_UDAF(){};
virtual ~regr_slope(){};
virtual ReturnCode init(mcsv1Context* context,
ColumnDatum* colTypes);
virtual ReturnCode init(mcsv1Context* context, ColumnDatum* colTypes);
virtual ReturnCode reset(mcsv1Context* context);
virtual ReturnCode reset(mcsv1Context* context);
virtual ReturnCode nextValue(mcsv1Context* context, ColumnDatum* valsIn);
virtual ReturnCode nextValue(mcsv1Context* context, ColumnDatum* valsIn);
virtual ReturnCode subEvaluate(mcsv1Context* context, const UserData* valIn);
virtual ReturnCode subEvaluate(mcsv1Context* context, const UserData* valIn);
virtual ReturnCode evaluate(mcsv1Context* context, static_any::any& valOut);
virtual ReturnCode evaluate(mcsv1Context* context, static_any::any& valOut);
virtual ReturnCode dropValue(mcsv1Context* context, ColumnDatum* valsDropped);
virtual ReturnCode dropValue(mcsv1Context* context, ColumnDatum* valsDropped);
protected:
protected:
};
}; // namespace
}; // namespace mcsv1sdk
#undef EXPORT

144
utils/regr/regr_sxx.cpp
View File

@ -26,11 +26,11 @@ using namespace mcsv1sdk;
class Add_regr_sxx_ToUDAFMap
{
public:
Add_regr_sxx_ToUDAFMap()
{
UDAFMap::getMap()["regr_sxx"] = new regr_sxx();
}
public:
Add_regr_sxx_ToUDAFMap()
{
UDAFMap::getMap()["regr_sxx"] = new regr_sxx();
}
};
static Add_regr_sxx_ToUDAFMap addToMap;
@ -38,103 +38,99 @@ static Add_regr_sxx_ToUDAFMap addToMap;
// Use the simple data model
struct regr_sxx_data
{
uint64_t cnt;
long double sumx;
long double sumx2; // sum of (x squared)
uint64_t cnt;
long double sumx;
long double sumx2; // sum of (x squared)
};
mcsv1_UDAF::ReturnCode regr_sxx::init(mcsv1Context* context,
ColumnDatum* colTypes)
mcsv1_UDAF::ReturnCode regr_sxx::init(mcsv1Context* context, ColumnDatum* colTypes)
{
if (context->getParameterCount() != 2)
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("regr_sxx() with other than 2 arguments");
return mcsv1_UDAF::ERROR;
}
if (!(isNumeric(colTypes[1].dataType)))
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("regr_sxx() with a non-numeric independant (second) argument");
return mcsv1_UDAF::ERROR;
}
context->setUserDataSize(sizeof(regr_sxx_data));
context->setResultType(execplan::CalpontSystemCatalog::DOUBLE);
context->setColWidth(8);
context->setScale(DECIMAL_NOT_SPECIFIED);
context->setPrecision(0);
context->setRunFlag(mcsv1sdk::UDAF_IGNORE_NULLS);
return mcsv1_UDAF::SUCCESS;
if (context->getParameterCount() != 2)
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("regr_sxx() with other than 2 arguments");
return mcsv1_UDAF::ERROR;
}
if (!(isNumeric(colTypes[1].dataType)))
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("regr_sxx() with a non-numeric independant (second) argument");
return mcsv1_UDAF::ERROR;
}
context->setUserDataSize(sizeof(regr_sxx_data));
context->setResultType(execplan::CalpontSystemCatalog::DOUBLE);
context->setColWidth(8);
context->setScale(DECIMAL_NOT_SPECIFIED);
context->setPrecision(0);
context->setRunFlag(mcsv1sdk::UDAF_IGNORE_NULLS);
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_sxx::reset(mcsv1Context* context)
{
struct regr_sxx_data* data = (struct regr_sxx_data*)context->getUserData()->data;
data->cnt = 0;
data->sumx = 0.0;
data->sumx2 = 0.0;
return mcsv1_UDAF::SUCCESS;
struct regr_sxx_data* data = (struct regr_sxx_data*)context->getUserData()->data;
data->cnt = 0;
data->sumx = 0.0;
data->sumx2 = 0.0;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_sxx::nextValue(mcsv1Context* context, ColumnDatum* valsIn)
{
double valx = toDouble(valsIn[1]);
struct regr_sxx_data* data = (struct regr_sxx_data*)context->getUserData()->data;
double valx = toDouble(valsIn[1]);
struct regr_sxx_data* data = (struct regr_sxx_data*)context->getUserData()->data;
data->sumx += valx;
data->sumx2 += valx*valx;
data->sumx += valx;
data->sumx2 += valx * valx;
++data->cnt;
return mcsv1_UDAF::SUCCESS;
++data->cnt;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_sxx::subEvaluate(mcsv1Context* context, const UserData* userDataIn)
{
if (!userDataIn)
{
return mcsv1_UDAF::SUCCESS;
}
struct regr_sxx_data* outData = (struct regr_sxx_data*)context->getUserData()->data;
struct regr_sxx_data* inData = (struct regr_sxx_data*)userDataIn->data;
outData->sumx += inData->sumx;
outData->sumx2 += inData->sumx2;
outData->cnt += inData->cnt;
if (!userDataIn)
{
return mcsv1_UDAF::SUCCESS;
}
struct regr_sxx_data* outData = (struct regr_sxx_data*)context->getUserData()->data;
struct regr_sxx_data* inData = (struct regr_sxx_data*)userDataIn->data;
outData->sumx += inData->sumx;
outData->sumx2 += inData->sumx2;
outData->cnt += inData->cnt;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_sxx::evaluate(mcsv1Context* context, static_any::any& valOut)
{
struct regr_sxx_data* data = (struct regr_sxx_data*)context->getUserData()->data;
long double N = data->cnt;
if (N > 0)
{
long double regr_sxx = (data->sumx2 - (data->sumx * data->sumx / N));
if (regr_sxx < 0) // catch -0
regr_sxx = 0;
valOut = static_cast<double>(regr_sxx);
}
return mcsv1_UDAF::SUCCESS;
struct regr_sxx_data* data = (struct regr_sxx_data*)context->getUserData()->data;
long double N = data->cnt;
if (N > 0)
{
long double regr_sxx = (data->sumx2 - (data->sumx * data->sumx / N));
if (regr_sxx < 0) // catch -0
regr_sxx = 0;
valOut = static_cast<double>(regr_sxx);
}
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_sxx::dropValue(mcsv1Context* context, ColumnDatum* valsDropped)
{
double valx = toDouble(valsDropped[1]);
struct regr_sxx_data* data = (struct regr_sxx_data*)context->getUserData()->data;
double valx = toDouble(valsDropped[1]);
struct regr_sxx_data* data = (struct regr_sxx_data*)context->getUserData()->data;
data->sumx -= valx;
data->sumx2 -= valx*valx;
data->sumx -= valx;
data->sumx2 -= valx * valx;
--data->cnt;
--data->cnt;
return mcsv1_UDAF::SUCCESS;
return mcsv1_UDAF::SUCCESS;
}

38
utils/regr/regr_sxx.h
View File

@ -16,10 +16,10 @@
MA 02110-1301, USA. */
/***********************************************************************
* $Id$
*
* regr_sxx.h
***********************************************************************/
* $Id$
*
* regr_sxx.h
***********************************************************************/
/**
* Columnstore interface for for the regr_sxx function
@ -51,34 +51,30 @@
namespace mcsv1sdk
{
// Return the regr_sxx value of the dataset
class regr_sxx : public mcsv1_UDAF
class regr_sxx : public mcsv1_UDAF
{
public:
// Defaults OK
regr_sxx() : mcsv1_UDAF() {};
virtual ~regr_sxx() {};
public:
// Defaults OK
regr_sxx() : mcsv1_UDAF(){};
virtual ~regr_sxx(){};
virtual ReturnCode init(mcsv1Context* context,
ColumnDatum* colTypes);
virtual ReturnCode init(mcsv1Context* context, ColumnDatum* colTypes);
virtual ReturnCode reset(mcsv1Context* context);
virtual ReturnCode reset(mcsv1Context* context);
virtual ReturnCode nextValue(mcsv1Context* context, ColumnDatum* valsIn);
virtual ReturnCode nextValue(mcsv1Context* context, ColumnDatum* valsIn);
virtual ReturnCode subEvaluate(mcsv1Context* context, const UserData* valIn);
virtual ReturnCode subEvaluate(mcsv1Context* context, const UserData* valIn);
virtual ReturnCode evaluate(mcsv1Context* context, static_any::any& valOut);
virtual ReturnCode evaluate(mcsv1Context* context, static_any::any& valOut);
virtual ReturnCode dropValue(mcsv1Context* context, ColumnDatum* valsDropped);
virtual ReturnCode dropValue(mcsv1Context* context, ColumnDatum* valsDropped);
protected:
protected:
};
}; // namespace
}; // namespace mcsv1sdk
#undef EXPORT

154
utils/regr/regr_sxy.cpp
View File

@ -26,11 +26,11 @@ using namespace mcsv1sdk;
class Add_regr_sxy_ToUDAFMap
{
public:
Add_regr_sxy_ToUDAFMap()
{
UDAFMap::getMap()["regr_sxy"] = new regr_sxy();
}
public:
Add_regr_sxy_ToUDAFMap()
{
UDAFMap::getMap()["regr_sxy"] = new regr_sxy();
}
};
static Add_regr_sxy_ToUDAFMap addToMap;
@ -38,111 +38,107 @@ static Add_regr_sxy_ToUDAFMap addToMap;
// Use the simple data model
struct regr_sxy_data
{
uint64_t cnt;
long double sumx;
long double sumy;
long double sumxy; // sum of x * y
uint64_t cnt;
long double sumx;
long double sumy;
long double sumxy; // sum of x * y
};
mcsv1_UDAF::ReturnCode regr_sxy::init(mcsv1Context* context,
ColumnDatum* colTypes)
mcsv1_UDAF::ReturnCode regr_sxy::init(mcsv1Context* context, ColumnDatum* colTypes)
{
if (context->getParameterCount() != 2)
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("regr_sxy() with other than 2 arguments");
return mcsv1_UDAF::ERROR;
}
if (!(isNumeric(colTypes[0].dataType) && isNumeric(colTypes[1].dataType)))
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("regr_sxy() with non-numeric arguments");
return mcsv1_UDAF::ERROR;
}
context->setUserDataSize(sizeof(regr_sxy_data));
context->setResultType(execplan::CalpontSystemCatalog::DOUBLE);
context->setColWidth(8);
context->setScale(DECIMAL_NOT_SPECIFIED);
context->setPrecision(0);
context->setRunFlag(mcsv1sdk::UDAF_IGNORE_NULLS);
return mcsv1_UDAF::SUCCESS;
if (context->getParameterCount() != 2)
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("regr_sxy() with other than 2 arguments");
return mcsv1_UDAF::ERROR;
}
if (!(isNumeric(colTypes[0].dataType) && isNumeric(colTypes[1].dataType)))
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("regr_sxy() with non-numeric arguments");
return mcsv1_UDAF::ERROR;
}
context->setUserDataSize(sizeof(regr_sxy_data));
context->setResultType(execplan::CalpontSystemCatalog::DOUBLE);
context->setColWidth(8);
context->setScale(DECIMAL_NOT_SPECIFIED);
context->setPrecision(0);
context->setRunFlag(mcsv1sdk::UDAF_IGNORE_NULLS);
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_sxy::reset(mcsv1Context* context)
{
struct regr_sxy_data* data = (struct regr_sxy_data*)context->getUserData()->data;
data->cnt = 0;
data->sumx = 0.0;
data->sumy = 0.0;
data->sumxy = 0.0;
return mcsv1_UDAF::SUCCESS;
struct regr_sxy_data* data = (struct regr_sxy_data*)context->getUserData()->data;
data->cnt = 0;
data->sumx = 0.0;
data->sumy = 0.0;
data->sumxy = 0.0;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_sxy::nextValue(mcsv1Context* context, ColumnDatum* valsIn)
{
double valy = toDouble(valsIn[0]);
double valx = toDouble(valsIn[1]);
struct regr_sxy_data* data = (struct regr_sxy_data*)context->getUserData()->data;
double valy = toDouble(valsIn[0]);
double valx = toDouble(valsIn[1]);
struct regr_sxy_data* data = (struct regr_sxy_data*)context->getUserData()->data;
data->sumy += valy;
data->sumy += valy;
data->sumx += valx;
data->sumx += valx;
data->sumxy += valx*valy;
data->sumxy += valx * valy;
++data->cnt;
return mcsv1_UDAF::SUCCESS;
++data->cnt;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_sxy::subEvaluate(mcsv1Context* context, const UserData* userDataIn)
{
if (!userDataIn)
{
return mcsv1_UDAF::SUCCESS;
}
struct regr_sxy_data* outData = (struct regr_sxy_data*)context->getUserData()->data;
struct regr_sxy_data* inData = (struct regr_sxy_data*)userDataIn->data;
outData->sumx += inData->sumx;
outData->sumy += inData->sumy;
outData->sumxy += inData->sumxy;
outData->cnt += inData->cnt;
if (!userDataIn)
{
return mcsv1_UDAF::SUCCESS;
}
struct regr_sxy_data* outData = (struct regr_sxy_data*)context->getUserData()->data;
struct regr_sxy_data* inData = (struct regr_sxy_data*)userDataIn->data;
outData->sumx += inData->sumx;
outData->sumy += inData->sumy;
outData->sumxy += inData->sumxy;
outData->cnt += inData->cnt;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_sxy::evaluate(mcsv1Context* context, static_any::any& valOut)
{
struct regr_sxy_data* data = (struct regr_sxy_data*)context->getUserData()->data;
long double N = data->cnt;
if (N > 0)
{
long double regr_sxy = (data->sumxy - ((data->sumx * data->sumy) / N));
valOut = static_cast<double>(regr_sxy);
}
return mcsv1_UDAF::SUCCESS;
struct regr_sxy_data* data = (struct regr_sxy_data*)context->getUserData()->data;
long double N = data->cnt;
if (N > 0)
{
long double regr_sxy = (data->sumxy - ((data->sumx * data->sumy) / N));
valOut = static_cast<double>(regr_sxy);
}
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_sxy::dropValue(mcsv1Context* context, ColumnDatum* valsDropped)
{
double valy = toDouble(valsDropped[0]);
double valx = toDouble(valsDropped[1]);
struct regr_sxy_data* data = (struct regr_sxy_data*)context->getUserData()->data;
double valy = toDouble(valsDropped[0]);
double valx = toDouble(valsDropped[1]);
struct regr_sxy_data* data = (struct regr_sxy_data*)context->getUserData()->data;
data->sumy -= valy;
data->sumy -= valy;
data->sumx -= valx;
data->sumx -= valx;
data->sumxy -= valx*valy;
--data->cnt;
data->sumxy -= valx * valy;
--data->cnt;
return mcsv1_UDAF::SUCCESS;
return mcsv1_UDAF::SUCCESS;
}

38
utils/regr/regr_sxy.h
View File

@ -16,10 +16,10 @@
MA 02110-1301, USA. */
/***********************************************************************
* $Id$
*
* regr_sxy.h
***********************************************************************/
* $Id$
*
* regr_sxy.h
***********************************************************************/
/**
* Columnstore interface for for the regr_sxy function
@ -51,34 +51,30 @@
namespace mcsv1sdk
{
// Return the regr_sxy value of the dataset
class regr_sxy : public mcsv1_UDAF
class regr_sxy : public mcsv1_UDAF
{
public:
// Defaults OK
regr_sxy() : mcsv1_UDAF() {};
virtual ~regr_sxy() {};
public:
// Defaults OK
regr_sxy() : mcsv1_UDAF(){};
virtual ~regr_sxy(){};
virtual ReturnCode init(mcsv1Context* context,
ColumnDatum* colTypes);
virtual ReturnCode init(mcsv1Context* context, ColumnDatum* colTypes);
virtual ReturnCode reset(mcsv1Context* context);
virtual ReturnCode reset(mcsv1Context* context);
virtual ReturnCode nextValue(mcsv1Context* context, ColumnDatum* valsIn);
virtual ReturnCode nextValue(mcsv1Context* context, ColumnDatum* valsIn);
virtual ReturnCode subEvaluate(mcsv1Context* context, const UserData* valIn);
virtual ReturnCode subEvaluate(mcsv1Context* context, const UserData* valIn);
virtual ReturnCode evaluate(mcsv1Context* context, static_any::any& valOut);
virtual ReturnCode evaluate(mcsv1Context* context, static_any::any& valOut);
virtual ReturnCode dropValue(mcsv1Context* context, ColumnDatum* valsDropped);
virtual ReturnCode dropValue(mcsv1Context* context, ColumnDatum* valsDropped);
protected:
protected:
};
}; // namespace
}; // namespace mcsv1sdk
#undef EXPORT

144
utils/regr/regr_syy.cpp
View File

@ -26,11 +26,11 @@ using namespace mcsv1sdk;
class Add_regr_syy_ToUDAFMap
{
public:
Add_regr_syy_ToUDAFMap()
{
UDAFMap::getMap()["regr_syy"] = new regr_syy();
}
public:
Add_regr_syy_ToUDAFMap()
{
UDAFMap::getMap()["regr_syy"] = new regr_syy();
}
};
static Add_regr_syy_ToUDAFMap addToMap;
@ -38,103 +38,99 @@ static Add_regr_syy_ToUDAFMap addToMap;
// Use the simple data model
struct regr_syy_data
{
uint64_t cnt;
long double sumy;
long double sumy2; // sum of (y squared)
uint64_t cnt;
long double sumy;
long double sumy2; // sum of (y squared)
};
mcsv1_UDAF::ReturnCode regr_syy::init(mcsv1Context* context,
ColumnDatum* colTypes)
mcsv1_UDAF::ReturnCode regr_syy::init(mcsv1Context* context, ColumnDatum* colTypes)
{
if (context->getParameterCount() != 2)
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("regr_syy() with other than 2 arguments");
return mcsv1_UDAF::ERROR;
}
if (!(isNumeric(colTypes[0].dataType)))
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("regr_syy() with a non-numeric dependant (first) argument");
return mcsv1_UDAF::ERROR;
}
context->setUserDataSize(sizeof(regr_syy_data));
context->setResultType(execplan::CalpontSystemCatalog::DOUBLE);
context->setColWidth(8);
context->setScale(DECIMAL_NOT_SPECIFIED);
context->setPrecision(0);
context->setRunFlag(mcsv1sdk::UDAF_IGNORE_NULLS);
return mcsv1_UDAF::SUCCESS;
if (context->getParameterCount() != 2)
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("regr_syy() with other than 2 arguments");
return mcsv1_UDAF::ERROR;
}
if (!(isNumeric(colTypes[0].dataType)))
{
// The error message will be prepended with
// "The storage engine for the table doesn't support "
context->setErrorMessage("regr_syy() with a non-numeric dependant (first) argument");
return mcsv1_UDAF::ERROR;
}
context->setUserDataSize(sizeof(regr_syy_data));
context->setResultType(execplan::CalpontSystemCatalog::DOUBLE);
context->setColWidth(8);
context->setScale(DECIMAL_NOT_SPECIFIED);
context->setPrecision(0);
context->setRunFlag(mcsv1sdk::UDAF_IGNORE_NULLS);
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_syy::reset(mcsv1Context* context)
{
struct regr_syy_data* data = (struct regr_syy_data*)context->getUserData()->data;
data->cnt = 0;
data->sumy = 0.0;
data->sumy2 = 0.0;
return mcsv1_UDAF::SUCCESS;
struct regr_syy_data* data = (struct regr_syy_data*)context->getUserData()->data;
data->cnt = 0;
data->sumy = 0.0;
data->sumy2 = 0.0;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_syy::nextValue(mcsv1Context* context, ColumnDatum* valsIn)
{
double valy = toDouble(valsIn[0]);
struct regr_syy_data* data = (struct regr_syy_data*)context->getUserData()->data;
double valy = toDouble(valsIn[0]);
struct regr_syy_data* data = (struct regr_syy_data*)context->getUserData()->data;
data->sumy += valy;
data->sumy2 += valy*valy;
data->sumy += valy;
data->sumy2 += valy * valy;
++data->cnt;
return mcsv1_UDAF::SUCCESS;
++data->cnt;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_syy::subEvaluate(mcsv1Context* context, const UserData* userDataIn)
{
if (!userDataIn)
{
return mcsv1_UDAF::SUCCESS;
}
struct regr_syy_data* outData = (struct regr_syy_data*)context->getUserData()->data;
struct regr_syy_data* inData = (struct regr_syy_data*)userDataIn->data;
outData->sumy += inData->sumy;
outData->sumy2 += inData->sumy2;
outData->cnt += inData->cnt;
if (!userDataIn)
{
return mcsv1_UDAF::SUCCESS;
}
struct regr_syy_data* outData = (struct regr_syy_data*)context->getUserData()->data;
struct regr_syy_data* inData = (struct regr_syy_data*)userDataIn->data;
outData->sumy += inData->sumy;
outData->sumy2 += inData->sumy2;
outData->cnt += inData->cnt;
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_syy::evaluate(mcsv1Context* context, static_any::any& valOut)
{
struct regr_syy_data* data = (struct regr_syy_data*)context->getUserData()->data;
long double N = data->cnt;
if (N > 0)
{
long double var_popy = (data->sumy2 - (data->sumy * data->sumy / N));
if (var_popy < 0) // might be -0
var_popy = 0;
valOut = static_cast<double>(var_popy);
}
return mcsv1_UDAF::SUCCESS;
struct regr_syy_data* data = (struct regr_syy_data*)context->getUserData()->data;
long double N = data->cnt;
if (N > 0)
{
long double var_popy = (data->sumy2 - (data->sumy * data->sumy / N));
if (var_popy < 0) // might be -0
var_popy = 0;
valOut = static_cast<double>(var_popy);
}
return mcsv1_UDAF::SUCCESS;
}
mcsv1_UDAF::ReturnCode regr_syy::dropValue(mcsv1Context* context, ColumnDatum* valsDropped)
{
double valy = toDouble(valsDropped[0]);
struct regr_syy_data* data = (struct regr_syy_data*)context->getUserData()->data;
double valy = toDouble(valsDropped[0]);
struct regr_syy_data* data = (struct regr_syy_data*)context->getUserData()->data;
data->sumy -= valy;
data->sumy2 -= valy*valy;
data->sumy -= valy;
data->sumy2 -= valy * valy;
--data->cnt;
--data->cnt;
return mcsv1_UDAF::SUCCESS;
return mcsv1_UDAF::SUCCESS;
}

38
utils/regr/regr_syy.h
View File

@ -16,10 +16,10 @@
MA 02110-1301, USA. */
/***********************************************************************
* $Id$
*
* regr_syy.h
***********************************************************************/
* $Id$
*
* regr_syy.h
***********************************************************************/
/**
* Columnstore interface for for the regr_syy function
@ -51,34 +51,30 @@
namespace mcsv1sdk
{
// Return the regr_syy value of the dataset
class regr_syy : public mcsv1_UDAF
class regr_syy : public mcsv1_UDAF
{
public:
// Defaults OK
regr_syy() : mcsv1_UDAF() {};
virtual ~regr_syy() {};
public:
// Defaults OK
regr_syy() : mcsv1_UDAF(){};
virtual ~regr_syy(){};
virtual ReturnCode init(mcsv1Context* context,
ColumnDatum* colTypes);
virtual ReturnCode init(mcsv1Context* context, ColumnDatum* colTypes);
virtual ReturnCode reset(mcsv1Context* context);
virtual ReturnCode reset(mcsv1Context* context);
virtual ReturnCode nextValue(mcsv1Context* context, ColumnDatum* valsIn);
virtual ReturnCode nextValue(mcsv1Context* context, ColumnDatum* valsIn);
virtual ReturnCode subEvaluate(mcsv1Context* context, const UserData* valIn);
virtual ReturnCode subEvaluate(mcsv1Context* context, const UserData* valIn);
virtual ReturnCode evaluate(mcsv1Context* context, static_any::any& valOut);
virtual ReturnCode evaluate(mcsv1Context* context, static_any::any& valOut);
virtual ReturnCode dropValue(mcsv1Context* context, ColumnDatum* valsDropped);
virtual ReturnCode dropValue(mcsv1Context* context, ColumnDatum* valsDropped);
protected:
protected:
};
}; // namespace
}; // namespace mcsv1sdk
#undef EXPORT

2580
utils/regr/regrmysql.cpp
View File

File diff suppressed because it is too large Load Diff