自学教程：C++ ARR_DATA_PTR函数代码示例

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));}

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;}

Datumalpine_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);}

Datumalpine_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);}

Datumalpine_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);}

VectorTypeNativeArrayToMappedVector(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);}

Datumalpine_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);}

Datumalpine_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 boolfloat8arr_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);}

Datumalpine_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);}	

Datumalpine_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 */voidtest__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 */voidtest__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);}

Datumsvec_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 SparseDatasdata_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;}

Datumlt_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 boolarray_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);}