Datum
nb_classify_combine(PG_FUNCTION_ARGS)
{
HeapTupleHeader tup;
TupleDesc resultDesc;
HeapTuple result;
Datum resultDatum[3];
bool resultNull[3];
nb_classify_state state[2];
float8 *prior_data1;
float8 *prior_data2;
int nclasses;
int i;
/* Need to be called with two arguments */
if (PG_NARGS() != 2)
{
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("nb_classify_final called with %d arguments",
PG_NARGS())));
}
if (PG_ARGISNULL(0) && PG_ARGISNULL(1))
PG_RETURN_NULL();
if (PG_ARGISNULL(1))
PG_RETURN_DATUM(PG_GETARG_DATUM(0));
if (PG_ARGISNULL(0))
PG_RETURN_DATUM(PG_GETARG_DATUM(1));
tup = (fcinfo->context && IsA(fcinfo->context, AggState))
? PG_GETARG_HEAPTUPLEHEADER(0)
: PG_GETARG_HEAPTUPLEHEADER_COPY(0);
get_nb_state(tup, &state[0], 0);
nclasses = ARR_DIMS(state[0].classes)[0];
get_nb_state(PG_GETARG_HEAPTUPLEHEADER(1), &state[1], nclasses);
/* The the prior with maximum likelyhood */
prior_data1 = (float8*) ARR_DATA_PTR(state[0].accum);
prior_data2 = (float8*) ARR_DATA_PTR(state[1].accum);
nclasses = ARR_DIMS(state[0].classes)[0];
for (i = 0; i < nclasses; i++)
prior_data1[i] += prior_data2[i];
/* Construct the return tuple */
if (get_call_result_type(fcinfo, NULL, &resultDesc) != TYPEFUNC_COMPOSITE)
elog(ERROR, "return type must be a row type");
BlessTupleDesc(resultDesc);
resultDatum[0] = PointerGetDatum(state[0].classes);
resultDatum[1] = PointerGetDatum(state[0].accum);
resultDatum[2] = PointerGetDatum(state[0].total);
resultNull[0] = false;
resultNull[1] = false;
resultNull[2] = false;
result = heap_form_tuple(resultDesc, resultDatum, resultNull);
PG_RETURN_DATUM(HeapTupleGetDatum(result));
}
Datum
pgstrom_final_avg_float8_accum(PG_FUNCTION_ARGS)
{
MemoryContext aggcxt;
MemoryContext oldcxt;
ArrayType *xarray;
ArrayType *yarray;
float8 *x, *y;
if (!AggCheckCallContext(fcinfo, &aggcxt))
elog(ERROR, "aggregate function called in non-aggregate context");
if (PG_ARGISNULL(1))
elog(ERROR, "Null state was supplied");
if (PG_ARGISNULL(0))
{
oldcxt = MemoryContextSwitchTo(aggcxt);
xarray = PG_GETARG_ARRAYTYPE_P_COPY(1);
MemoryContextSwitchTo(oldcxt);
}
else
{
xarray = PG_GETARG_ARRAYTYPE_P(0);
yarray = PG_GETARG_ARRAYTYPE_P(1);
x = (float8 *)ARR_DATA_PTR(xarray);
y = (float8 *)ARR_DATA_PTR(yarray);
x[0] += y[0];
x[1] += y[1];
}
PG_RETURN_POINTER(xarray);
}
static jvalue _doubleArray_coerceDatum(Type self, Datum arg)
{
jvalue result;
ArrayType* v = DatumGetArrayTypeP(arg);
jsize nElems = (jsize)ArrayGetNItems(ARR_NDIM(v), ARR_DIMS(v));
jdoubleArray doubleArray = JNI_newDoubleArray(nElems);
#if (PGSQL_MAJOR_VER == 8 && PGSQL_MINOR_VER < 2)
JNI_setDoubleArrayRegion(doubleArray, 0, nElems, (jdouble*)ARR_DATA_PTR(v));
#else
if(ARR_HASNULL(v))
{
jsize idx;
jboolean isCopy = JNI_FALSE;
bits8* nullBitMap = ARR_NULLBITMAP(v);
jdouble* values = (jdouble*)ARR_DATA_PTR(v);
jdouble* elems = JNI_getDoubleArrayElements(doubleArray, &isCopy);
for(idx = 0; idx < nElems; ++idx)
{
if(arrayIsNull(nullBitMap, idx))
elems[idx] = 0;
else
elems[idx] = *values++;
}
JNI_releaseDoubleArrayElements(doubleArray, elems, JNI_COMMIT);
}
else
JNI_setDoubleArrayRegion(doubleArray, 0, nElems, (jdouble*)ARR_DATA_PTR(v));
#endif
result.l = (jobject)doubleArray;
return result;
}
static Datum _doubleArray_coerceObject(Type self, jobject doubleArray)
{
ArrayType* v;
jsize nElems;
if(doubleArray == 0)
return 0;
nElems = JNI_getArrayLength((jarray)doubleArray);
#if (PGSQL_MAJOR_VER == 8 && PGSQL_MINOR_VER < 2)
v = createArrayType(nElems, sizeof(jdouble), FLOAT8OID);
#else
v = createArrayType(nElems, sizeof(jdouble), FLOAT8OID, false);
#endif
if(!JNI_isInstanceOf( doubleArray, s_DoubleArray_class))
JNI_getDoubleArrayRegion((jdoubleArray)doubleArray, 0,
nElems, (jdouble*)ARR_DATA_PTR(v));
else
{
int idx = 0;
jdouble *array = (jdouble*)ARR_DATA_PTR(v);
for(idx = 0; idx < nElems; ++idx)
{
array[idx] = JNI_callDoubleMethod(JNI_getObjectArrayElement(doubleArray, idx),
s_Double_doubleValue);
}
}
PG_RETURN_ARRAYTYPE_P(v);
}
static jvalue _booleanArray_coerceDatum(Type self, Datum arg)
{
jvalue result;
ArrayType* v = DatumGetArrayTypeP(arg);
jsize nElems = (jsize)ArrayGetNItems(ARR_NDIM(v), ARR_DIMS(v));
jbooleanArray booleanArray = JNI_newBooleanArray(nElems);
if(ARR_HASNULL(v))
{
jsize idx;
jboolean isCopy = JNI_FALSE;
bits8* nullBitMap = ARR_NULLBITMAP(v);
jboolean* values = (jboolean*)ARR_DATA_PTR(v);
jboolean* elems = JNI_getBooleanArrayElements(booleanArray, &isCopy);
for(idx = 0; idx < nElems; ++idx)
{
if(arrayIsNull(nullBitMap, idx))
elems[idx] = 0;
else
elems[idx] = *values++;
}
JNI_releaseBooleanArrayElements(booleanArray, elems, JNI_COMMIT);
}
else
JNI_setBooleanArrayRegion(booleanArray, 0, nElems, (jboolean*)ARR_DATA_PTR(v));
result.l = (jobject)booleanArray;
return result;
}
Datum
alpine_miner_lr_ca_pi(PG_FUNCTION_ARGS)
{
ArrayType *beta_arg, *columns_arg;
float8 *beta_data, *columns_data;
int beta_count, columns_count;
bool add_intercept_arg;
double gx = 0.0;
double pi = 0.0;
if (PG_ARGISNULL(0) || PG_ARGISNULL(1) || PG_ARGISNULL(2))
{
PG_RETURN_NULL();
}
beta_arg = PG_GETARG_ARRAYTYPE_P(0);
columns_arg = PG_GETARG_ARRAYTYPE_P(1);
add_intercept_arg = PG_GETARG_BOOL(2);
beta_data = (float8*) ARR_DATA_PTR(beta_arg);
columns_data = (float8*) ARR_DATA_PTR(columns_arg);
beta_count = ARR_DIMS(beta_arg)[0];
columns_count = ARR_DIMS(columns_arg)[0];
pi = alpine_miner_compute_pi(beta_data, beta_count, columns_data, columns_count, add_intercept_arg);
PG_RETURN_FLOAT8(pi);
}
Datum
alpine_miner_dot_product( PG_FUNCTION_ARGS)
{
ArrayType *ax = PG_GETARG_ARRAYTYPE_P(0);
ArrayType *ay = PG_GETARG_ARRAYTYPE_P(1);
float8 *x, *y, z = 0.0;
int i, *dimx, *dimy;
/* Sanity check: does it look like an array at all? */
if (ARR_NDIM(ax) <= 0 || ARR_NDIM(ax) > MAXDIM)
PG_RETURN_NULL();
if (ARR_NDIM(ay) <= 0 || ARR_NDIM(ay) > MAXDIM)
PG_RETURN_NULL();
// Assign variables for the input arrays
x = (float8 *) ARR_DATA_PTR( ax);
y = (float8 *) ARR_DATA_PTR( ay);
// Read arrays dimensions
dimx = ARR_DIMS( ax);
dimy = ARR_DIMS( ay);
// Run the calculation
for (i=0; i < dimx[0] && i < dimy[0]; i++) {
z = z + (x[i] * y[i]);
}
PG_RETURN_FLOAT8( z);
}
Datum
alpine_miner_has_novel_product( PG_FUNCTION_ARGS)
{
ArrayType *ax = PG_GETARG_ARRAYTYPE_P(0);
ArrayType *ay = PG_GETARG_ARRAYTYPE_P(1);
float8 *x, *y;
int i, *dimx, *dimy;
/* Sanity check: does it look like an array at all? */
if (ARR_NDIM(ax) <= 0 || ARR_NDIM(ax) > MAXDIM)
PG_RETURN_NULL();
if (ARR_NDIM(ay) <= 0 || ARR_NDIM(ay) > MAXDIM)
PG_RETURN_NULL();
// Assign variables for the input arrays
x = (float8 *) ARR_DATA_PTR( ax);
y = (float8 *) ARR_DATA_PTR( ay);
// Read arrays dimensions
dimx = ARR_DIMS( ax);
dimy = ARR_DIMS( ay);
// Check one by one
for (i=0; i < dimx[0] && i < dimy[0]; i++) {
if (x[i]==0.0 && y[i]!=0.0) {
PG_RETURN_INT32( 1);
}
}
PG_RETURN_INT32( 0);
}
VectorType
NativeArrayToMappedVector(Datum inDatum, bool inNeedMutableClone) {
typedef typename VectorType::Scalar Scalar;
ArrayType* array = reinterpret_cast<ArrayType*>(
madlib_DatumGetArrayTypeP(inDatum));
size_t arraySize = ARR_NDIM(array) == 1
? ARR_DIMS(array)[0]
: ARR_DIMS(array)[0] * ARR_DIMS(array)[1];
if (!(ARR_NDIM(array) == 1
|| (ARR_NDIM(array) == 2
&& (ARR_DIMS(array)[0] == 1 || ARR_DIMS(array)[1] == 1)))) {
std::stringstream errorMsg;
errorMsg << "Invalid type conversion to matrix. Expected one-"
"dimensional array but got " << ARR_NDIM(array)
<< " dimensions.";
throw std::invalid_argument(errorMsg.str());
}
Scalar* origData = reinterpret_cast<Scalar*>(ARR_DATA_PTR(array));
Scalar* data;
if (inNeedMutableClone) {
data = reinterpret_cast<Scalar*>(
defaultAllocator().allocate<dbal::FunctionContext, dbal::DoNotZero,
dbal::ThrowBadAlloc>(sizeof(Scalar) * arraySize));
std::copy(origData, origData + arraySize, data);
} else {
data = reinterpret_cast<Scalar*>(ARR_DATA_PTR(array));
}
return VectorType(data, arraySize);
}
Datum findentropy(PG_FUNCTION_ARGS) {
ArrayType *values = PG_GETARG_ARRAYTYPE_P(0);
ArrayType *classes = PG_GETARG_ARRAYTYPE_P(1);
int posvalues = PG_GETARG_INT32(2);
int posclasses = PG_GETARG_INT32(3);
int dimvalues = ARR_NDIM(values);
int *dimsvalues = ARR_DIMS(values);
int numvalues = ArrayGetNItems(dimvalues,dimsvalues);
int32 *vals_values=(int32 *)ARR_DATA_PTR(values);
int32 *vals_classes=(int32 *)ARR_DATA_PTR(classes);
int *pre_entropy = (int*)palloc(sizeof(int)*posclasses);
int i;
int j;
int sum = 0;
float8 result = 0;
for (i=0; i<posvalues; ++i){
memset(pre_entropy, 0, sizeof(int)*posclasses);
for(j=0, sum=0; j<numvalues; ++j){
if(vals_values[j] == (i+1)){
pre_entropy[vals_classes[j]-1]++;
sum++;
}
}
result += entropyWeighted(pre_entropy, posclasses, (float)sum, (float)numvalues);
}
free(pre_entropy);
PG_RETURN_FLOAT8((float8)result);
}
Datum
alpine_plda_first(PG_FUNCTION_ARGS)
{
ArrayType *assign;
ArrayType *topiccount;
int32 * assign_array_data;
int32 * topiccount_array_data;
Datum values[2];
int32 column_size,topicnumber;
int32 temptopic;
int32 k;
bool * isnulls ;
TupleDesc tuple;
HeapTuple ret;
Datum * arr1;
Datum * arr2;
if (PG_ARGISNULL(0)){
PG_RETURN_NULL();
}
column_size=PG_GETARG_INT32(0);
topicnumber=PG_GETARG_INT32(1);
arr1 = palloc0(column_size * sizeof(Datum));//Datum *
assign = construct_array(arr1,column_size,INT4OID,4,true,'i');
assign_array_data = (int32 *)ARR_DATA_PTR(assign);
arr2 = palloc0(topicnumber * sizeof(Datum));//Datum *
topiccount = construct_array(arr2,topicnumber,INT4OID,4,true,'i');
topiccount_array_data = (int32 *)ARR_DATA_PTR(topiccount);
for ( k = 0; k < column_size; k++){
temptopic = random() % topicnumber + 1;
assign_array_data[k] = temptopic;
topiccount_array_data[temptopic-1]++;
}
values[0] = PointerGetDatum(assign);
values[1] = PointerGetDatum(topiccount);
if (get_call_result_type(fcinfo, NULL, &tuple) != TYPEFUNC_COMPOSITE)
ereport(ERROR,
(errcode( ERRCODE_FEATURE_NOT_SUPPORTED ),
errmsg( "function returning record called in context "
"that cannot accept type record" )));
tuple = BlessTupleDesc(tuple);
isnulls = palloc0(2 * sizeof(bool));
ret = heap_form_tuple(tuple, values, isnulls);
if (isnulls[0] || isnulls[1])
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("function \"%s\" produced null results",
format_procedure(fcinfo->flinfo->fn_oid))));
PG_RETURN_DATUM(HeapTupleGetDatum(ret));
}
Datum cword_count(PG_FUNCTION_ARGS)
{
ArrayType * count_arr, * doc_arr, * topics_arr;
int32 * count, * doc, * topics;
int32 doclen, num_topics, dsize, i;
Datum * array;
int32 idx;
if (!(fcinfo->context && IsA(fcinfo->context, AggState)))
elog(ERROR, "cword_count not used as part of an aggregate");
doclen = PG_GETARG_INT32(3);
num_topics = PG_GETARG_INT32(4);
dsize = PG_GETARG_INT32(5);
/* Construct a zero'd array at the first call of this function */
if (PG_ARGISNULL(0)) {
array = palloc0(dsize*num_topics*sizeof(Datum));
count_arr =
construct_array(array,dsize*num_topics,INT4OID,4,true,'i');
} else {
count_arr = PG_GETARG_ARRAYTYPE_P(0);
}
doc_arr = PG_GETARG_ARRAYTYPE_P(1);
topics_arr = PG_GETARG_ARRAYTYPE_P(2);
/* Check that the input arrays are of the right dimension and type */
if (ARR_NDIM(count_arr) != 1 || ARR_ELEMTYPE(count_arr) != INT4OID ||
ARR_NDIM(doc_arr) != 1 || ARR_ELEMTYPE(doc_arr) != INT4OID ||
ARR_NDIM(topics_arr) != 1 || ARR_ELEMTYPE(topics_arr) != INT4OID)
ereport
(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("transition function \"%s\" called with invalid parameters",
format_procedure(fcinfo->flinfo->fn_oid))));
count = (int32 *)ARR_DATA_PTR(count_arr);
doc = (int32 *)ARR_DATA_PTR(doc_arr);
topics = (int32 *)ARR_DATA_PTR(topics_arr);
/* Update the word-topic count */
for (i=0; i!=doclen; i++) {
idx = (doc[i]-1) * num_topics + (topics[i]-1);
if (idx < 0 || idx >= dsize*num_topics)
ereport
(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("function \"%s\" called with invalid parameters",
format_procedure(fcinfo->flinfo->fn_oid))));
count[idx]++;
}
PG_RETURN_BYTEA_P(count_arr);
}
Datum
alpine_miner_lr_ca_derivative(PG_FUNCTION_ARGS)
{
ArrayType *beta_arg, *columns_arg, *result;
float8 *beta_data, *columns_data, *result_data;
int beta_count, columns_count, result_count;
bool add_intercept_arg;
double weight_arg;
int y_arg;
int size;
double gx = 0.0;
double pi = 0.0;
if (PG_ARGISNULL(0) || PG_ARGISNULL(1) || PG_ARGISNULL(2) || PG_ARGISNULL(3) || PG_ARGISNULL(4) || PG_ARGISNULL(5)){
PG_RETURN_NULL();
}
result = PG_GETARG_ARRAYTYPE_P(0);
beta_arg = PG_GETARG_ARRAYTYPE_P(1);
columns_arg = PG_GETARG_ARRAYTYPE_P(2);
add_intercept_arg = PG_GETARG_BOOL(3);
weight_arg = PG_GETARG_FLOAT8(4);
y_arg = PG_GETARG_INT32(5);
result_data = (float8*) ARR_DATA_PTR(result);
beta_data = (float8*) ARR_DATA_PTR(beta_arg);
columns_data = (float8*) ARR_DATA_PTR(columns_arg);
result_count = ARR_DIMS(result)[0];
beta_count = ARR_DIMS(beta_arg)[0];
columns_count = ARR_DIMS(columns_arg)[0];
// float8 * column_array_data = (float8*) ARR_DATA_PTR(column_array);
if (result_count == 1){
result_count = beta_count;
size = result_count * sizeof(float8) + ARR_OVERHEAD_NONULLS(1);
result = (ArrayType *) palloc(size);
SET_VARSIZE(result, size);
result->ndim = 1;
result->dataoffset = 0;
result->elemtype = FLOAT8OID;
ARR_DIMS(result)[0] = result_count;
ARR_LBOUND(result)[0] = 1;
result_data = (float8*) ARR_DATA_PTR(result);
memset(result_data, 0, result_count * sizeof(float8));
}
pi = alpine_miner_compute_pi(beta_data, beta_count, columns_data, columns_count, add_intercept_arg);
alpine_miner_compute_derivative(columns_count,columns_data, result_data
,weight_arg, y_arg, add_intercept_arg, pi);
PG_RETURN_ARRAYTYPE_P(result);
}
/*
* Equality
*/
static bool
float8arr_equals_internal(ArrayType *left, ArrayType *right)
{
int dimleft = ARR_NDIM(left), dimright = ARR_NDIM(right);
int *dimsleft = ARR_DIMS(left), *dimsright = ARR_DIMS(right);
int numleft = ArrayGetNItems(dimleft,dimsleft);
int numright = ArrayGetNItems(dimright,dimsright);
double *vals_left=(double *)ARR_DATA_PTR(left), *vals_right=(double *)ARR_DATA_PTR(right);
bits8 *bitmap_left=ARR_NULLBITMAP(left), *bitmap_right=ARR_NULLBITMAP(right);
int bitmask=1;
if ((dimsleft!=dimsright) || (numleft!=numright))
{
return(false);
}
/*
* Note that we are only defined for FLOAT8OID
*/
//get_typlenbyvalalign(ARR_ELEMTYPE(array),
// &typlen, &typbyval, &typalign);
/*
* First we'll check to see if the null bitmaps are equivalent
*/
if (bitmap_left)
if (! bitmap_right) return(false);
if (bitmap_right)
if (! bitmap_left) return(false);
if (bitmap_left)
{
for (int i=0; i<numleft; i++)
{
if ((*bitmap_left & bitmask) == 0)
if ((*bitmap_left & bitmask) != 0)
return(false);
bitmask <<= 1;
if (bitmask == 0x100)
{
bitmap_left++;
bitmask = 1;
}
}
}
/*
* Now we check for equality of all array values
*/
for (int i=0; i<numleft; i++)
if (vals_left[i] != vals_right[i]) return(false);
return(true);
}
Datum
alpine_miner_covar_sam_accum(PG_FUNCTION_ARGS)
{
ArrayType *state;
float8 * state_array_data;
ArrayType * column_array;
int column_size;
float8 * column_array_data;
int i;
int k ;
int j;
if (PG_ARGISNULL(0)){
PG_RETURN_NULL();
}
state = PG_GETARG_ARRAYTYPE_P(0);
state_array_data = (float8*) ARR_DATA_PTR(state);
column_array = PG_GETARG_ARRAYTYPE_P(1);
column_size = ARR_DIMS(column_array)[0];
column_array_data = (float8*) ARR_DATA_PTR(column_array);
if (ARR_DIMS(state)[0] == 1){
int result_size = column_size * ( column_size + 1)/2 + column_size+2;
int size = result_size * sizeof(float8) + ARR_OVERHEAD_NONULLS(1);
state = (ArrayType *) palloc(size);
SET_VARSIZE(state, size);
state->ndim = 1;
state->dataoffset = 0;
state->elemtype = FLOAT8OID;
ARR_DIMS(state)[0] = result_size;
ARR_LBOUND(state)[0] = 1;
state_array_data = (float8*) ARR_DATA_PTR(state);
memset(state_array_data, 0, result_size * sizeof(float8));
}
k = 0;
for ( i = 0; i < column_size; i++){
for(j = i; j < column_size; j++){
state_array_data[k] += column_array_data[i] * column_array_data[j];
k++;
}
}
for( i = 0; i < column_size; i++){
state_array_data[k + i] += column_array_data[i];
}
state_array_data[k+i]++;
state_array_data[k+i+1]=column_size;
PG_RETURN_ARRAYTYPE_P(state);
}
Datum
alpine_miner_covar_sam_final(PG_FUNCTION_ARGS){
ArrayType *state ;
ArrayType *result;
float8 * resultData;
float8 * state_array_data;
int total_length;
int column_size;
float8 row_size;
int result_size;
int size;
int k=0;
int i,j;
int sam_row_size;
if (PG_ARGISNULL(0))
PG_RETURN_NULL();
state = PG_GETARG_ARRAYTYPE_P(0);
state_array_data = (float8*) ARR_DATA_PTR(state);
total_length=ARR_DIMS(state)[0];
column_size=state_array_data[total_length-1];
row_size=state_array_data[total_length-2];
result_size=column_size*(column_size+1)/2;
size = result_size * sizeof(float8) + ARR_OVERHEAD_NONULLS(1);
result = (ArrayType *) palloc(size);
SET_VARSIZE(result, size);
result->ndim = 1;
result->dataoffset = 0;
result->elemtype = FLOAT8OID;
ARR_DIMS(result)[0] = result_size;
ARR_LBOUND(result)[0] = 1;
resultData = (float8*) ARR_DATA_PTR(result);
memset(resultData, 0, result_size * sizeof(float8));
sam_row_size=row_size-1;
if(sam_row_size<=0)
sam_row_size=1;
k=0;
for ( i = 0; i < column_size; i++){
for( j = i; j < column_size; j++){
resultData[k] =state_array_data[k]/sam_row_size- state_array_data[result_size+i] * state_array_data[result_size+j]/row_size/sam_row_size;
k++;
}
}
PG_RETURN_ARRAYTYPE_P(result);
}
/*
* nb_classify_probabilities - calculate naive bayes probabilty vector
*
* Similar to nb_classify_final, except the return value is the vector of
* probabilities for each class rather than the text value of the most
* likely class.
*/
Datum
nb_classify_probabilities(PG_FUNCTION_ARGS)
{
nb_classify_state state;
int64 *total_data;
float8 maxprior, normalize;
float8 *prior_data;
int i, nclasses;
if (PG_NARGS() != 1)
{
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("nb_classify_probabilities called with %d arguments",
PG_NARGS())));
}
if (PG_ARGISNULL(0))
PG_RETURN_NULL();
get_nb_state(PG_GETARG_HEAPTUPLEHEADER_COPY(0), &state, 0);
/* The the prior with maximum likelyhood */
prior_data = (float8*) ARR_DATA_PTR(state.accum);
total_data = (int64*) ARR_DATA_PTR(state.total);
nclasses = ARR_DIMS(state.classes)[0];
/* Adjust prior to account for percentages of total distributions */
for (i = 0; i < nclasses; i++)
prior_data[i] += log(total_data[i]);
/* Calculate max prior to improve numeric stability */
maxprior = prior_data[0];
for (i = 1; i < nclasses; i++)
maxprior = Max(maxprior, prior_data[i]);
/* Convert log values into true values */
for (normalize = i = 0; i < nclasses; i++)
{
prior_data[i] = exp(prior_data[i] - maxprior);
normalize += prior_data[i];
}
/* Normalize results */
for (i = 0; i < nclasses; i++)
prior_data[i] /= normalize;
PG_RETURN_ARRAYTYPE_P(state.accum);
}
Datum randomTopics(PG_FUNCTION_ARGS)
{
int32 doclen = PG_GETARG_INT32(0);
int32 num_topics = PG_GETARG_INT32(1);
ArrayType * ret_topics_arr, * ret_topic_d_arr;
int32 * ret_topics, * ret_topic_d;
Datum * arr1 = palloc0(doclen * sizeof(Datum));
ret_topics_arr = construct_array(arr1,doclen,INT4OID,4,true,'i');
ret_topics = (int32 *)ARR_DATA_PTR(ret_topics_arr);
Datum * arr2 = palloc0(num_topics * sizeof(Datum));
ret_topic_d_arr = construct_array(arr2,num_topics,INT4OID,4,true,'i');
ret_topic_d = (int32 *)ARR_DATA_PTR(ret_topic_d_arr);
/* Sample topics */
int i, rtopic;
for (i=0; i!=doclen; i++) {
rtopic = random() % num_topics + 1;
ret_topics[i] = rtopic;
ret_topic_d[rtopic-1]++;
}
/* Package up the return arrays */
Datum values[2];
values[0] = PointerGetDatum(ret_topics_arr);
values[1] = PointerGetDatum(ret_topic_d_arr);
TupleDesc tuple;
if (get_call_result_type(fcinfo, NULL, &tuple) != TYPEFUNC_COMPOSITE)
ereport(ERROR,
(errcode( ERRCODE_FEATURE_NOT_SUPPORTED ),
errmsg( "function returning record called in context "
"that cannot accept type record" )));
tuple = BlessTupleDesc(tuple);
bool * isnulls = palloc0(2 * sizeof(bool));
HeapTuple ret = heap_form_tuple(tuple, values, isnulls);
if (isnulls[0] || isnulls[1])
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("function \"%s\" produced null results",
format_procedure(fcinfo->flinfo->fn_oid),i)));
PG_RETURN_DATUM(HeapTupleGetDatum(ret));
}
Datum
_lca(PG_FUNCTION_ARGS)
{
ArrayType *la = PG_GETARG_ARRAYTYPE_P(0);
int num = ArrayGetNItems(ARR_NDIM(la), ARR_DIMS(la));
ltree *item = (ltree *) ARR_DATA_PTR(la);
ltree **a,
*res;
if (ARR_NDIM(la) > 1)
ereport(ERROR,
(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
errmsg("array must be one-dimensional")));
if (ARR_HASNULL(la))
ereport(ERROR,
(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
errmsg("array must not contain nulls")));
a = (ltree **) palloc(sizeof(ltree *) * num);
while (num > 0)
{
num--;
a[num] = item;
item = NEXTVAL(item);
}
res = lca_inner(a, ArrayGetNItems(ARR_NDIM(la), ARR_DIMS(la)));
pfree(a);
PG_FREE_IF_COPY(la, 0);
if (res)
PG_RETURN_POINTER(res);
else
PG_RETURN_NULL();
}
/*
* GUC array: mix of PGC_USERSET, PGC_POSTMASTER, PGC_SUSET
* return ArrayType contains non-PGC_USERSET
*/
void
test__GUCArrayReset__mix_guc(void **state)
{
ArrayType *in;
ArrayType *out;
Datum d;
List *guc_list;
int elems;
build_guc_variables();
will_return(superuser, false);
/* construct text array */
elems = 4;
guc_list = list_make4("password_encryption=on", "log_error_verbosity=verbose", "application_name=mixtest", "allow_system_table_mods=dml");
in = create_guc_array(guc_list, elems);
out = GUCArrayReset(in);
assert_not_null(out);
assert_int_equal(ARR_DIMS(out)[0], 1);
d = PointerGetDatum(ARR_DATA_PTR(out));
assert_int_equal(strlen("log_error_verbosity=verbose"), VARLEN(d));
assert_memory_equal(VARDATA(d), "log_error_verbosity=verbose", VARLEN(d));
list_free(guc_list);
pfree(in);
pfree(out);
}
/*
* GUC array: one invalid guc + non-userset guc
* return ArrayType contain non-userset guc, ignore invalid guc
*/
void
test__GUCArrayReset__invalid_guc(void **state)
{
ArrayType *in;
ArrayType *out;
Datum d;
List *guc_list;
int elems;
build_guc_variables();
will_return(superuser, false);
/* construct text array */
elems = 2;
guc_list = list_make2("invalid_guc=true", "gp_log_format=text");
in = create_guc_array(guc_list, elems);
out = GUCArrayReset(in);
assert_not_null(out);
assert_int_equal(ARR_DIMS(out)[0], 1);
d = PointerGetDatum(ARR_DATA_PTR(out));
assert_int_equal(strlen("gp_log_format=text"), VARLEN(d));
assert_memory_equal(VARDATA(d), "gp_log_format=text", VARLEN(d));
list_free(guc_list);
pfree(in);
pfree(out);
}
Datum
svec_cast_float8arr(PG_FUNCTION_ARGS) {
ArrayType *A_PG = PG_GETARG_ARRAYTYPE_P(0);
SvecType *output_svec;
if (ARR_ELEMTYPE(A_PG) != FLOAT8OID)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("svec_cast_float8arr only defined over float8[]")));
if (ARR_NDIM(A_PG) != 1)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("svec_cast_float8arr only defined over 1 dimensional arrays"))
);
if (ARR_NULLBITMAP(A_PG))
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("svec_cast_float8arr does not allow null bitmaps on arrays"))
);
/* Extract array */
{
int dimension = ARR_DIMS(A_PG)[0];
float8 *array = (float8 *)ARR_DATA_PTR(A_PG);
/* Create the output SVEC */
SparseData sdata = float8arr_to_sdata(array,dimension);
output_svec = svec_from_sparsedata(sdata,true);
}
PG_RETURN_SVECTYPE_P(output_svec);
}
/*
* Returns a SparseData formed from a dense float8[] in uncompressed format.
* This is useful for creating a SparseData without processing that can be
* used by the SparseData processing routines.
*/
static SparseData
sdata_uncompressed_from_float8arr_internal(ArrayType *array)
{
int dim = ARR_NDIM(array);
int *dims = ARR_DIMS(array);
int num = ArrayGetNItems(dim,dims);
double *vals =(double *)ARR_DATA_PTR(array);
bits8 *bitmap = ARR_NULLBITMAP(array);
int bitmask=1;
SparseData result = makeInplaceSparseData(
(char *)vals,NULL,
num*sizeof(float8),0,FLOAT8OID,
num,num);
/*
* Convert null items into zeros
*/
if (bitmap)
{
for (int i=0; i<num; i++)
{
if ((*bitmap& bitmask) == 0)
vals[i] = 0.;
bitmask <<= 1;
if (bitmask == 0x100)
{
bitmap++;
bitmask = 1;
}
}
}
return(result);
}
static jvalue _Array_coerceDatum(Type self, Datum arg)
{
jvalue result;
jsize idx;
Type elemType = Type_getElementType(self);
int16 elemLength = Type_getLength(elemType);
char elemAlign = Type_getAlign(elemType);
bool elemByValue = Type_isByValue(elemType);
ArrayType* v = DatumGetArrayTypeP(arg);
jsize nElems = (jsize)ArrayGetNItems(ARR_NDIM(v), ARR_DIMS(v));
jobjectArray objArray = JNI_newObjectArray(nElems, Type_getJavaClass(elemType), 0);
const char* values = ARR_DATA_PTR(v);
bits8* nullBitMap = ARR_NULLBITMAP(v);
for(idx = 0; idx < nElems; ++idx)
{
if(arrayIsNull(nullBitMap, idx))
JNI_setObjectArrayElement(objArray, idx, 0);
else
{
Datum value = fetch_att(values, elemByValue, elemLength);
jvalue obj = Type_coerceDatum(elemType, value);
JNI_setObjectArrayElement(objArray, idx, obj.l);
JNI_deleteLocalRef(obj.l);
values = att_addlength_datum(values, elemLength, PointerGetDatum(values));
values = (char*)att_align_nominal(values, elemAlign);
}
}
result.l = (jobject)objArray;
return result;
}
Datum
lt_q_regex(PG_FUNCTION_ARGS)
{
ltree *tree = PG_GETARG_LTREE(0);
ArrayType *_query = PG_GETARG_ARRAYTYPE_P(1);
lquery *query = (lquery *) ARR_DATA_PTR(_query);
bool res = false;
int num = ArrayGetNItems(ARR_NDIM(_query), ARR_DIMS(_query));
if (ARR_NDIM(_query) != 1)
ereport(ERROR,
(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
errmsg("array must be one-dimensional")));
while (num > 0)
{
if (DatumGetBool(DirectFunctionCall2(ltq_regex,
PointerGetDatum(tree), PointerGetDatum(query))))
{
res = true;
break;
}
num--;
query = NEXTVAL(query);
}
PG_FREE_IF_COPY(tree, 0);
PG_FREE_IF_COPY(_query, 1);
PG_RETURN_BOOL(res);
}
Datum
_lt_q_regex(PG_FUNCTION_ARGS)
{
ArrayType *_tree = PG_GETARG_ARRAYTYPE_P(0);
ArrayType *_query = PG_GETARG_ARRAYTYPE_P(1);
lquery *query = (lquery *) ARR_DATA_PTR(_query);
bool res = false;
int num = ArrayGetNItems(ARR_NDIM(_query), ARR_DIMS(_query));
if (ARR_NDIM(_query) > 1)
ereport(ERROR,
(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
errmsg("array must be one-dimensional")));
if (ARR_HASNULL(_query))
ereport(ERROR,
(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
errmsg("array must not contain nulls")));
while (num > 0)
{
if (array_iterator(_tree, ltq_regex, (void *) query, NULL))
{
res = true;
break;
}
num--;
query = (lquery *) NEXTVAL(query);
}
PG_FREE_IF_COPY(_tree, 0);
PG_FREE_IF_COPY(_query, 1);
PG_RETURN_BOOL(res);
}
static bool
array_iterator(ArrayType *la, PGCALL2 callback, void *param, ltree **found)
{
int num = ArrayGetNItems(ARR_NDIM(la), ARR_DIMS(la));
ltree *item = (ltree *) ARR_DATA_PTR(la);
if (ARR_NDIM(la) > 1)
ereport(ERROR,
(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
errmsg("array must be one-dimensional")));
if (ARR_HASNULL(la))
ereport(ERROR,
(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
errmsg("array must not contain nulls")));
if (found)
*found = NULL;
while (num > 0)
{
if (DatumGetBool(DirectFunctionCall2(callback,
PointerGetDatum(item), PointerGetDatum(param))))
{
if (found)
*found = item;
return true;
}
num--;
item = NEXTVAL(item);
}
return false;
}
void array_loop(ArrayType *array, int32 start, array_iter *iter)
{
iter->array = array;
iter->ptr = ARR_DATA_PTR(array);
iter->max = ARR_DIMS(array)[0];
get_typlenbyvalalign(ARR_ELEMTYPE(array),
&iter->typlen,
&iter->typbyval,
&iter->typalign);
/* If we are starting in the middle of the array, then scan forward */
start = start - ARR_LBOUND(array)[0];
if (start <= 0)
iter->index = start;
else
{
/*
* could probably be more efficient for fixed length arrays, but
* they would still require adjustments for nulls.
*/
iter->index = 0;
while (start--)
{
Datum d;
bool isna;
array_next(iter, &d, &isna);
}
}
}
/*
* pivot_find() - Searchs an array of labels for a matching value.
*
* Returns: index of found value, or -1 if not found
*
* It may eventually do something smarter than a linear scan, but
* for now this is sufficient given that we don't know anything about the
* order of 'labels'.
*
*/
static int pivot_find(ArrayType *labels, text *attr)
{
char *labelsp;
int i, nelem, asize;
int16 typlen;
bool typbyval;
char typalign;
if (ARR_ELEMTYPE(labels) != TEXTOID)
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
errmsg("pivot_accum: labels are not type text")));
/* Text alignment properties */
get_typlenbyvalalign(TEXTOID, &typlen, &typbyval, &typalign);
/* Get the size of the input attribute, we'll use this for fast compares */
asize = VARSIZE(attr);
/* The labels array is an array of varying length text, scan it adding
the length of the previous entry until we are done or we have found
a match. */
labelsp = (char *) ARR_DATA_PTR(labels);
nelem = ARR_DIMS(labels)[0];
for (i = 0; i < nelem; i++)
{
int lsize = VARSIZE(labelsp);
if (asize == lsize && !memcmp(attr, labelsp, lsize))
return i; /* Found */
labelsp = labelsp + lsize;
labelsp = (char*) att_align(labelsp, typalign);
}
return -1; /* Not found */
}
Datum pcpoint_from_double_array(PG_FUNCTION_ARGS)
{
uint32 pcid = PG_GETARG_INT32(0);
ArrayType *arrptr = PG_GETARG_ARRAYTYPE_P(1);
int nelems;
float8 *vals;
PCPOINT *pt;
PCSCHEMA *schema = pc_schema_from_pcid(pcid, fcinfo);
SERIALIZED_POINT *serpt;
if ( ! schema )
elog(ERROR, "unable to load schema for pcid = %d", pcid);
if ( ARR_ELEMTYPE(arrptr) != FLOAT8OID )
elog(ERROR, "array must be of float8[]");
if ( ARR_NDIM(arrptr) != 1 )
elog(ERROR, "float8[] must have only one dimension");
if ( ARR_HASNULL(arrptr) )
elog(ERROR, "float8[] must not have null elements");
nelems = ARR_DIMS(arrptr)[0];
if ( nelems != schema->ndims || ARR_LBOUND(arrptr)[0] > 1 )
elog(ERROR, "array dimensions do not match schema dimensions of pcid = %d", pcid);
vals = (float8*) ARR_DATA_PTR(arrptr);
pt = pc_point_from_double_array(schema, vals, nelems);
serpt = pc_point_serialize(pt);
pc_point_free(pt);
PG_RETURN_POINTER(serpt);
}
