You've already forked mariadb-columnstore-engine
mirror of
https://github.com/mariadb-corporation/mariadb-columnstore-engine.git
synced 2025-10-31 18:30:33 +03:00
496 lines
11 KiB
C++
496 lines
11 KiB
C++
#include <my_config.h>
|
|
#include <cmath>
|
|
#include <iostream>
|
|
#include <sstream>
|
|
using namespace std;
|
|
|
|
#include "idb_mysql.h"
|
|
|
|
namespace
|
|
{
|
|
inline double cvtArgToDouble(int t, const char* v)
|
|
{
|
|
double d = 0.0;
|
|
|
|
switch (t)
|
|
{
|
|
case INT_RESULT:
|
|
d = (double)(*((long long*)v));
|
|
break;
|
|
|
|
case REAL_RESULT:
|
|
d = *((double*)v);
|
|
break;
|
|
|
|
case DECIMAL_RESULT:
|
|
case STRING_RESULT:
|
|
d = strtod(v, 0);
|
|
break;
|
|
|
|
case ROW_RESULT:
|
|
break;
|
|
}
|
|
|
|
return d;
|
|
}
|
|
inline long long cvtArgToInt(int t, const char* v)
|
|
{
|
|
long long ll = 0;
|
|
|
|
switch (t)
|
|
{
|
|
case INT_RESULT:
|
|
ll = *((long long*)v);
|
|
break;
|
|
|
|
case REAL_RESULT:
|
|
ll = (long long)(*((double*)v));
|
|
break;
|
|
|
|
case DECIMAL_RESULT:
|
|
case STRING_RESULT:
|
|
ll = strtoll(v, 0, 0);
|
|
break;
|
|
|
|
case ROW_RESULT:
|
|
break;
|
|
}
|
|
|
|
return ll;
|
|
}
|
|
inline string cvtArgToString(int t, const char* v)
|
|
{
|
|
string str;
|
|
|
|
switch (t)
|
|
{
|
|
case INT_RESULT:
|
|
{
|
|
long long ll;
|
|
ll = *((long long*)v);
|
|
ostringstream oss;
|
|
oss << ll;
|
|
str = oss.str();
|
|
break;
|
|
}
|
|
|
|
case REAL_RESULT:
|
|
{
|
|
double d;
|
|
d = *((double*)v);
|
|
ostringstream oss;
|
|
oss << d;
|
|
str = oss.str();
|
|
break;
|
|
}
|
|
|
|
case DECIMAL_RESULT:
|
|
case STRING_RESULT:
|
|
str = v;
|
|
break;
|
|
|
|
case ROW_RESULT:
|
|
break;
|
|
}
|
|
|
|
return str;
|
|
}
|
|
}
|
|
|
|
/****************************************************************************
|
|
* UDF function interface for MariaDB connector to recognize is defined in
|
|
* this section. MariaDB's UDF function creation guideline needs to be followed.
|
|
*
|
|
* Three interface need to be defined on the connector for each UDF function.
|
|
*
|
|
* XXX_init: To allocate the necessary memory for the UDF function and validate
|
|
* the input.
|
|
* XXX_deinit: To clean up the memory.
|
|
* XXX: The function implementation.
|
|
* Detailed instruction can be found at MariaDB source directory:
|
|
* ~/sql/udf_example.cc.
|
|
*
|
|
* Please note that the implementation of the function defined on the connector
|
|
* will only be called when all the input arguments are constant. e.g.,
|
|
* mcs_add(2,3). That way, the function does not run in a distributed fashion
|
|
* and could be slow. If there is a need for the UDF function to run with
|
|
* pure constant input, then one needs to put a implementation in the XXX
|
|
* body, which is very similar to the ones in getXXXval API. If there's no
|
|
* such need for a given UDF, then the XXX interface can just return a dummy
|
|
* result because this function will never be called.
|
|
*/
|
|
extern "C"
|
|
{
|
|
/**
|
|
* MCS_ADD connector stub
|
|
*/
|
|
#ifdef _MSC_VER
|
|
__declspec(dllexport)
|
|
#endif
|
|
my_bool mcs_add_init(UDF_INIT* initid, UDF_ARGS* args, char* message)
|
|
{
|
|
if (args->arg_count != 2)
|
|
{
|
|
strcpy(message, "mcs_add() requires two argument");
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef _MSC_VER
|
|
__declspec(dllexport)
|
|
#endif
|
|
void mcs_add_deinit(UDF_INIT* initid)
|
|
{
|
|
}
|
|
|
|
#ifdef _MSC_VER
|
|
__declspec(dllexport)
|
|
#endif
|
|
double mcs_add(UDF_INIT* initid, UDF_ARGS* args, char* is_null, char* error)
|
|
{
|
|
double op1, op2;
|
|
|
|
op1 = cvtArgToDouble(args->arg_type[0], args->args[0]);
|
|
op2 = cvtArgToDouble(args->arg_type[1], args->args[1]);
|
|
|
|
return op1 + op2;
|
|
}
|
|
|
|
/**
|
|
* MCS_ISNULL connector stub
|
|
*/
|
|
|
|
#ifdef _MSC_VER
|
|
__declspec(dllexport)
|
|
#endif
|
|
my_bool mcs_isnull_init(UDF_INIT* initid, UDF_ARGS* args, char* message)
|
|
{
|
|
if (args->arg_count != 1)
|
|
{
|
|
strcpy(message, "mcs_isnull() requires one argument");
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef _MSC_VER
|
|
__declspec(dllexport)
|
|
#endif
|
|
void mcs_isnull_deinit(UDF_INIT* initid)
|
|
{
|
|
}
|
|
|
|
#ifdef _MSC_VER
|
|
__declspec(dllexport)
|
|
#endif
|
|
long long mcs_isnull(UDF_INIT* initid, UDF_ARGS* args, char* is_null, char* error)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ALLNULL connector stub
|
|
*/
|
|
struct allnull_data
|
|
{
|
|
ulonglong totalQuantity;
|
|
ulonglong totalNulls;
|
|
};
|
|
|
|
#ifdef _MSC_VER
|
|
__declspec(dllexport)
|
|
#endif
|
|
my_bool allnull_init(UDF_INIT* initid, UDF_ARGS* args, char* message)
|
|
{
|
|
struct allnull_data* data;
|
|
// if (args->arg_count != 1)
|
|
// {
|
|
// strcpy(message,"allnull() requires one argument");
|
|
// return 1;
|
|
// }
|
|
|
|
if (!(data = (struct allnull_data*) malloc(sizeof(struct allnull_data))))
|
|
{
|
|
strmov(message, "Couldn't allocate memory");
|
|
return 1;
|
|
}
|
|
|
|
data->totalQuantity = 0;
|
|
data->totalNulls = 0;
|
|
|
|
initid->ptr = (char*)data;
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef _MSC_VER
|
|
__declspec(dllexport)
|
|
#endif
|
|
void allnull_deinit(UDF_INIT* initid)
|
|
{
|
|
free(initid->ptr);
|
|
}
|
|
|
|
#ifdef _MSC_VER
|
|
__declspec(dllexport)
|
|
#endif
|
|
long long allnull(UDF_INIT* initid, UDF_ARGS* args __attribute__((unused)),
|
|
char* is_null, char* error __attribute__((unused)))
|
|
{
|
|
struct allnull_data* data = (struct allnull_data*)initid->ptr;
|
|
return data->totalQuantity > 0 && data->totalNulls == data->totalQuantity;
|
|
}
|
|
|
|
#ifdef _MSC_VER
|
|
__declspec(dllexport)
|
|
#endif
|
|
void
|
|
allnull_clear(UDF_INIT* initid, char* is_null __attribute__((unused)),
|
|
char* message __attribute__((unused)))
|
|
{
|
|
struct allnull_data* data = (struct allnull_data*)initid->ptr;
|
|
data->totalQuantity = 0;
|
|
data->totalNulls = 0;
|
|
}
|
|
|
|
#ifdef _MSC_VER
|
|
__declspec(dllexport)
|
|
#endif
|
|
void
|
|
allnull_add(UDF_INIT* initid, UDF_ARGS* args,
|
|
char* is_null,
|
|
char* message __attribute__((unused)))
|
|
{
|
|
struct allnull_data* data = (struct allnull_data*)initid->ptr;
|
|
const char* word = args->args[0];
|
|
data->totalQuantity++;
|
|
|
|
if (!word)
|
|
{
|
|
data->totalNulls++;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* SSQ connector stub
|
|
*/
|
|
struct ssq_data
|
|
{
|
|
double sumsq;
|
|
};
|
|
|
|
#ifdef _MSC_VER
|
|
__declspec(dllexport)
|
|
#endif
|
|
my_bool ssq_init(UDF_INIT* initid, UDF_ARGS* args, char* message)
|
|
{
|
|
struct ssq_data* data;
|
|
|
|
if (args->arg_count != 1)
|
|
{
|
|
strcpy(message, "ssq() requires one argument");
|
|
return 1;
|
|
}
|
|
|
|
if (!(data = (struct ssq_data*) malloc(sizeof(struct ssq_data))))
|
|
{
|
|
strmov(message, "Couldn't allocate memory");
|
|
return 1;
|
|
}
|
|
|
|
data->sumsq = 0;
|
|
|
|
initid->ptr = (char*)data;
|
|
return 0;
|
|
}
|
|
|
|
#ifdef _MSC_VER
|
|
__declspec(dllexport)
|
|
#endif
|
|
void ssq_deinit(UDF_INIT* initid)
|
|
{
|
|
free(initid->ptr);
|
|
}
|
|
|
|
#ifdef _MSC_VER
|
|
__declspec(dllexport)
|
|
#endif
|
|
void
|
|
ssq_clear(UDF_INIT* initid, char* is_null __attribute__((unused)),
|
|
char* message __attribute__((unused)))
|
|
{
|
|
struct ssq_data* data = (struct ssq_data*)initid->ptr;
|
|
data->sumsq = 0;
|
|
}
|
|
|
|
#ifdef _MSC_VER
|
|
__declspec(dllexport)
|
|
#endif
|
|
void
|
|
ssq_add(UDF_INIT* initid, UDF_ARGS* args,
|
|
char* is_null,
|
|
char* message __attribute__((unused)))
|
|
{
|
|
struct ssq_data* data = (struct ssq_data*)initid->ptr;
|
|
double val = cvtArgToDouble(args->arg_type[0], args->args[0]);
|
|
data->sumsq = val * val;
|
|
}
|
|
|
|
#ifdef _MSC_VER
|
|
__declspec(dllexport)
|
|
#endif
|
|
long long ssq(UDF_INIT* initid, UDF_ARGS* args __attribute__((unused)),
|
|
char* is_null, char* error __attribute__((unused)))
|
|
{
|
|
struct ssq_data* data = (struct ssq_data*)initid->ptr;
|
|
return data->sumsq;
|
|
}
|
|
|
|
//=======================================================================
|
|
|
|
/**
|
|
* MEDIAN connector stub
|
|
*/
|
|
#ifdef _MSC_VER
|
|
__declspec(dllexport)
|
|
#endif
|
|
my_bool median_init(UDF_INIT* initid, UDF_ARGS* args, char* message)
|
|
{
|
|
if (args->arg_count != 1)
|
|
{
|
|
strcpy(message, "median() requires one argument");
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
if (!(data = (struct ssq_data*) malloc(sizeof(struct ssq_data))))
|
|
{
|
|
strmov(message,"Couldn't allocate memory");
|
|
return 1;
|
|
}
|
|
data->sumsq = 0;
|
|
|
|
initid->ptr = (char*)data;
|
|
*/
|
|
return 0;
|
|
}
|
|
|
|
#ifdef _MSC_VER
|
|
__declspec(dllexport)
|
|
#endif
|
|
void median_deinit(UDF_INIT* initid)
|
|
{
|
|
// free(initid->ptr);
|
|
}
|
|
|
|
#ifdef _MSC_VER
|
|
__declspec(dllexport)
|
|
#endif
|
|
void
|
|
median_clear(UDF_INIT* initid, char* is_null __attribute__((unused)),
|
|
char* message __attribute__((unused)))
|
|
{
|
|
// struct ssq_data* data = (struct ssq_data*)initid->ptr;
|
|
// data->sumsq = 0;
|
|
}
|
|
|
|
#ifdef _MSC_VER
|
|
__declspec(dllexport)
|
|
#endif
|
|
void
|
|
median_add(UDF_INIT* initid, UDF_ARGS* args,
|
|
char* is_null,
|
|
char* message __attribute__((unused)))
|
|
{
|
|
// struct ssq_data* data = (struct ssq_data*)initid->ptr;
|
|
// double val = cvtArgToDouble(args->arg_type[0], args->args[0]);
|
|
// data->sumsq = val*val;
|
|
}
|
|
|
|
#ifdef _MSC_VER
|
|
__declspec(dllexport)
|
|
#endif
|
|
long long median(UDF_INIT* initid, UDF_ARGS* args __attribute__((unused)),
|
|
char* is_null, char* error __attribute__((unused)))
|
|
{
|
|
// struct ssq_data* data = (struct ssq_data*)initid->ptr;
|
|
// return data->sumsq;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* avg_mode connector stub
|
|
*/
|
|
#ifdef _MSC_VER
|
|
__declspec(dllexport)
|
|
#endif
|
|
my_bool avg_mode_init(UDF_INIT* initid, UDF_ARGS* args, char* message)
|
|
{
|
|
if (args->arg_count != 1)
|
|
{
|
|
strcpy(message, "avg_mode() requires one argument");
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
if (!(data = (struct ssq_data*) malloc(sizeof(struct ssq_data))))
|
|
{
|
|
strmov(message,"Couldn't allocate memory");
|
|
return 1;
|
|
}
|
|
data->sumsq = 0;
|
|
|
|
initid->ptr = (char*)data;
|
|
*/
|
|
return 0;
|
|
}
|
|
|
|
#ifdef _MSC_VER
|
|
__declspec(dllexport)
|
|
#endif
|
|
void avg_mode_deinit(UDF_INIT* initid)
|
|
{
|
|
// free(initid->ptr);
|
|
}
|
|
|
|
#ifdef _MSC_VER
|
|
__declspec(dllexport)
|
|
#endif
|
|
void
|
|
avg_mode_clear(UDF_INIT* initid, char* is_null __attribute__((unused)),
|
|
char* message __attribute__((unused)))
|
|
{
|
|
// struct ssq_data* data = (struct ssq_data*)initid->ptr;
|
|
// data->sumsq = 0;
|
|
}
|
|
|
|
#ifdef _MSC_VER
|
|
__declspec(dllexport)
|
|
#endif
|
|
void
|
|
avg_mode_add(UDF_INIT* initid, UDF_ARGS* args,
|
|
char* is_null,
|
|
char* message __attribute__((unused)))
|
|
{
|
|
// struct ssq_data* data = (struct ssq_data*)initid->ptr;
|
|
// double val = cvtArgToDouble(args->arg_type[0], args->args[0]);
|
|
// data->sumsq = val*val;
|
|
}
|
|
|
|
#ifdef _MSC_VER
|
|
__declspec(dllexport)
|
|
#endif
|
|
long long avg_mode(UDF_INIT* initid, UDF_ARGS* args __attribute__((unused)),
|
|
char* is_null, char* error __attribute__((unused)))
|
|
{
|
|
// struct ssq_data* data = (struct ssq_data*)initid->ptr;
|
|
// return data->sumsq;
|
|
return 0;
|
|
}
|
|
}
|
|
// vim:ts=4 sw=4:
|
|
|