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

/* * extractValue support function */Datumginarrayextract(PG_FUNCTION_ARGS){	/* Make copy of array input to ensure it doesn't disappear while in use */	ArrayType  *array = PG_GETARG_ARRAYTYPE_P_COPY(0);	int32	   *nkeys = (int32 *) PG_GETARG_POINTER(1);	bool	  **nullFlags = (bool **) PG_GETARG_POINTER(2);	int16		elmlen;	bool		elmbyval;	char		elmalign;	Datum	   *elems;	bool	   *nulls;	int			nelems;	get_typlenbyvalalign(ARR_ELEMTYPE(array),						 &elmlen, &elmbyval, &elmalign);	deconstruct_array(array,					  ARR_ELEMTYPE(array),					  elmlen, elmbyval, elmalign,					  &elems, &nulls, &nelems);	*nkeys = nelems;	*nullFlags = nulls;	/* we should not free array, elems[i] points into it */	PG_RETURN_POINTER(elems);}

/* * extractQuery support function */Datumginqueryarrayextract(PG_FUNCTION_ARGS){	/* Make copy of array input to ensure it doesn't disappear while in use */	ArrayType  *array = PG_GETARG_ARRAYTYPE_P_COPY(0);	int32	   *nkeys = (int32 *) PG_GETARG_POINTER(1);	StrategyNumber strategy = PG_GETARG_UINT16(2);	/* bool   **pmatch = (bool **) PG_GETARG_POINTER(3); */	/* Pointer	   *extra_data = (Pointer *) PG_GETARG_POINTER(4); */	bool	  **nullFlags = (bool **) PG_GETARG_POINTER(5);	int32	   *searchMode = (int32 *) PG_GETARG_POINTER(6);	int16		elmlen;	bool		elmbyval;	char		elmalign;	Datum	   *elems;	bool	   *nulls;	int			nelems;	get_typlenbyvalalign(ARR_ELEMTYPE(array),						 &elmlen, &elmbyval, &elmalign);	deconstruct_array(array,					  ARR_ELEMTYPE(array),					  elmlen, elmbyval, elmalign,					  &elems, &nulls, &nelems);	*nkeys = nelems;	*nullFlags = nulls;	switch (strategy)	{		case GinOverlapStrategy:			*searchMode = GIN_SEARCH_MODE_DEFAULT;			break;		case GinContainsStrategy:			if (nelems > 0)				*searchMode = GIN_SEARCH_MODE_DEFAULT;			else	/* everything contains the empty set */				*searchMode = GIN_SEARCH_MODE_ALL;			break;		case GinContainedStrategy:			/* empty set is contained in everything */			*searchMode = GIN_SEARCH_MODE_INCLUDE_EMPTY;			break;		case GinEqualStrategy:			if (nelems > 0)				*searchMode = GIN_SEARCH_MODE_DEFAULT;			else				*searchMode = GIN_SEARCH_MODE_INCLUDE_EMPTY;			break;		default:			elog(ERROR, "ginqueryarrayextract: unknown strategy number: %d",				 strategy);	}	/* we should not free array, elems[i] points into it */	PG_RETURN_POINTER(elems);}

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_kmeans_distance_result(PG_FUNCTION_ARGS){	 ArrayType  *sample_arg, *data_arg;	 Datum     *sample_data, *data_data;	 Oid         sample_eltype,data_eltype;	 int16       sample_typlen, data_typlen;	 bool        sample_typbyval, data_typbyval;	 char        sample_typalign, data_typalign;	 bool       *sample_nulls, *data_nulls;	 int         sample_count, data_count,k,distanceMode;	 float       len;	 	if (PG_ARGISNULL(0) || PG_ARGISNULL(1) || PG_ARGISNULL(2)||PG_ARGISNULL(3) )	{		PG_RETURN_NULL();	}	 /* get sample_arg args */	 sample_arg=PG_GETARG_ARRAYTYPE_P(0);	  /* get sample_arg array element type */	   sample_eltype = ARR_ELEMTYPE(sample_arg);	  get_typlenbyvalalign(sample_eltype, &sample_typlen, &sample_typbyval, &sample_typalign);	  deconstruct_array(sample_arg, sample_eltype, 		sample_typlen, sample_typbyval, sample_typalign,		&sample_data, &sample_nulls, &sample_count);	    /* get data_arg args */        data_arg = PG_GETARG_ARRAYTYPE_P(1);	/* get data_arg array element type */		data_eltype = ARR_ELEMTYPE(data_arg);	get_typlenbyvalalign(data_eltype, &data_typlen, &data_typbyval, &data_typalign);	 deconstruct_array(data_arg, data_eltype, 		data_typlen, data_typbyval, data_typalign,		&data_data, &data_nulls, &data_count);	 k=PG_GETARG_INT32(2);	 distanceMode=PG_GETARG_INT32(3);	 len=alpine_miner_resultEuclideanDistance(sample_data,sample_count,data_data,data_count,k,distanceMode);	 pfree(sample_data);        pfree(sample_nulls);        pfree(data_data);        pfree(data_nulls);	PG_RETURN_FLOAT8(len);}

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

/* *		int2vectorrecv			- converts external binary format to int2vector */Datumint2vectorrecv(PG_FUNCTION_ARGS){	StringInfo	buf = (StringInfo) PG_GETARG_POINTER(0);	FunctionCallInfoData locfcinfo;	int2vector *result;	/*	 * Normally one would call array_recv() using DirectFunctionCall3, but	 * that does not work since array_recv wants to cache some data using	 * fcinfo->flinfo->fn_extra.  So we need to pass it our own flinfo	 * parameter.	 */	InitFunctionCallInfoData(locfcinfo, fcinfo->flinfo, 3, NULL, NULL);	locfcinfo.arg[0] = PointerGetDatum(buf);	locfcinfo.arg[1] = ObjectIdGetDatum(INT2OID);	locfcinfo.arg[2] = Int32GetDatum(-1);	locfcinfo.argnull[0] = false;	locfcinfo.argnull[1] = false;	locfcinfo.argnull[2] = false;	result = (int2vector *) DatumGetPointer(array_recv(&locfcinfo));	Assert(!locfcinfo.isnull);	/* sanity checks: int2vector must be 1-D, no nulls */	if (ARR_NDIM(result) != 1 ||		ARR_HASNULL(result) ||		ARR_ELEMTYPE(result) != INT2OID)		ereport(ERROR,				(errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),				 errmsg("invalid int2vector data")));	PG_RETURN_POINTER(result);}

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

void dump_bvf1_inputs(ArrayType *broker_list_p, text *sector_name_p) {	int ndim, nitems;	int *dim;	int16 typlen;	bool typbyval;	char typalign;	int i;	char *broker_list;	ndim = ARR_NDIM(broker_list_p);	dim = ARR_DIMS(broker_list_p);	nitems = ArrayGetNItems(ndim, dim);	get_typlenbyvalalign(ARR_ELEMTYPE(broker_list_p), &typlen, &typbyval,			&typalign);	broker_list = ARR_DATA_PTR(broker_list_p);	elog(NOTICE, "BVF1: INPUTS START");	for (i = 0; i < nitems; i++) {		elog(NOTICE, "BVF1: broker_list[%d] %s", i,				DatumGetCString(DirectFunctionCall1(textout,				PointerGetDatum(broker_list))));		broker_list = att_addlength_pointer(broker_list, typlen,				broker_list);		broker_list = (char *) att_align_nominal(broker_list, typalign);	}	elog(NOTICE, "BVF1: sector_name %s",			DatumGetCString(DirectFunctionCall1(textout,			PointerGetDatum(sector_name_p))));	elog(NOTICE, "BVF1: INPUTS END");}

/* Create a new int array with room for "num" elements */ArrayType *new_intArrayType(int num){	ArrayType  *r;	int			nbytes;	/* if no elements, return a zero-dimensional array */	if (num <= 0)	{		r = construct_empty_array(INT4OID);		return r;	}	nbytes = ARR_OVERHEAD_NONULLS(1) + sizeof(int) * num;	r = (ArrayType *) palloc0(nbytes);	SET_VARSIZE(r, nbytes);	ARR_NDIM(r) = 1;	r->dataoffset = 0;			/* marker for no null bitmap */	ARR_ELEMTYPE(r) = INT4OID;	ARR_DIMS(r)[0] = num;	ARR_LBOUND(r)[0] = 1;	return r;}

ArrayType* createArrayType(jsize nElems, size_t elemSize, Oid elemType, bool withNulls){	ArrayType* v;	Size nBytes = elemSize * nElems;	MemoryContext currCtx = Invocation_switchToUpperContext();	Size dataoffset;	if(withNulls)	{		dataoffset = ARR_OVERHEAD_WITHNULLS(1, nElems);		nBytes += dataoffset;	}	else	{		dataoffset = 0;			/* marker for no null bitmap */		nBytes += ARR_OVERHEAD_NONULLS(1);	}	v = (ArrayType*)palloc0(nBytes);	AssertVariableIsOfType(v->dataoffset, int32);	v->dataoffset = (int32)dataoffset;	MemoryContextSwitchTo(currCtx);	SET_VARSIZE(v, nBytes);	ARR_NDIM(v) = 1;	ARR_ELEMTYPE(v) = elemType;	*((int*)ARR_DIMS(v)) = nElems;	*((int*)ARR_LBOUND(v)) = 1;	return v;}

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

/* * cms_topn_frequency is a user-facing UDF which returns the estimated frequency * of an item. The first parameter is for CmsTopn and second is for the item to * return the frequency. */Datumcms_topn_frequency(PG_FUNCTION_ARGS){	CmsTopn *cmsTopn = (CmsTopn *) PG_GETARG_VARLENA_P(0);	ArrayType *topnArray = TopnArray(cmsTopn);	Datum item = PG_GETARG_DATUM(1);	Oid itemType = get_fn_expr_argtype(fcinfo->flinfo, 1);	TypeCacheEntry *itemTypeCacheEntry = NULL;	Frequency frequency = 0;	if (itemType == InvalidOid)	{		ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE),		                errmsg("could not determine input data types")));	}	if (topnArray != NULL && itemType != ARR_ELEMTYPE(topnArray))	{		ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE),		                errmsg("Not proper type for this cms_topn")));	}	itemTypeCacheEntry = lookup_type_cache(itemType, 0);	frequency = CmsTopnEstimateItemFrequency(cmsTopn, item, itemTypeCacheEntry);	PG_RETURN_INT32(frequency);}

/*  * 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 array_quantile(PG_FUNCTION_ARGS) {	// The formal PostgreSQL array object	ArrayType *array;	// The array element type	Oid arrayElementType;	// The array element type width	int16 arrayElementTypeWidth;	// The array element type "is passed by value" flags (not used, should always be true)	bool arrayElementTypeByValue;	// The array element type alignment codes (not used)	char arrayElementTypeAlignmentCode;	// The array contents, as PostgreSQL "datum" objects	Datum *arrayContent;	// List of "is null" flags for the array contents	bool *arrayNullFlags;	// The size of each array	int arrayLength;	int i,j, nelem;	double median, mad, f, quantile;	double *inarray;	if (PG_ARGISNULL(0) || PG_ARGISNULL(1)) 		ereport(ERROR, (errmsg("Null arrays not accepted")));	// Get array and quantile from input	array = PG_GETARG_ARRAYTYPE_P(0);	f = PG_GETARG_FLOAT8(1);	if (ARR_NDIM(array) != 1) 		ereport(ERROR, (errmsg("One-dimesional arrays are required")));	if (array_contains_nulls(array)) 		ereport(ERROR, (errmsg("Array contains null elements")));	arrayLength = (ARR_DIMS(array))[0];	arrayElementType = ARR_ELEMTYPE(array);	get_typlenbyvalalign(arrayElementType, &arrayElementTypeWidth, &arrayElementTypeByValue, &arrayElementTypeAlignmentCode);	deconstruct_array(array, arrayElementType, arrayElementTypeWidth, arrayElementTypeByValue, arrayElementTypeAlignmentCode, &arrayContent, &arrayNullFlags, &arrayLength);		inarray = (double*)malloc(arrayLength*sizeof(double));  	for (i=0; i<arrayLength; i++) {		inarray[i] = DatumGetFloat4(arrayContent[i]);	}	gsl_sort (inarray, 1, arrayLength);	quantile = gsl_stats_quantile_from_sorted_data(inarray, 1, arrayLength, f);	PG_RETURN_FLOAT8(quantile);}

/* * Function used as extractValue and extractQuery both */Datumginarrayextract(PG_FUNCTION_ARGS){	ArrayType  *array;	int32	   *nentries = (int32 *) PG_GETARG_POINTER(1);	Datum	   *entries = NULL;	int16		elmlen;	bool		elmbyval;	char		elmalign;	/*	 * we should guarantee that array will not be destroyed during all	 * operation	 */	array = PG_GETARG_ARRAYTYPE_P_COPY(0);	ARRAYCHECK(array);	get_typlenbyvalalign(ARR_ELEMTYPE(array),						 &elmlen, &elmbyval, &elmalign);	deconstruct_array(array,					  ARR_ELEMTYPE(array),					  elmlen, elmbyval, elmalign,					  &entries, NULL, (int *) nentries);	if (*nentries == 0 && PG_NARGS() == 3)	{		switch (PG_GETARG_UINT16(2))	/* StrategyNumber */		{			case GinOverlapStrategy:				*nentries = -1; /* nobody can be found */				break;			case GinContainsStrategy:			case GinContainedStrategy:			case GinEqualStrategy:			default:			/* require fullscan: GIN can't find void								 * arrays */				break;		}	}	/* we should not free array, entries[i] points into it */	PG_RETURN_POINTER(entries);}

/* * Find 'findelem' within array 'v'. Returns -1 if not found in an array * without any NULL elements, NULL if not found but one or more NULLs appeared * in the array. * * Declared STRICT, must not be called with NULL input(s). */Datumarray_idx(PG_FUNCTION_ARGS){    Datum        findelem = PG_GETARG_DATUM(0);    ArrayType    *v = PG_GETARG_ARRAYTYPE_P(1);    Oid          arg0_typeid = get_fn_expr_argtype(fcinfo->flinfo, 0);    Oid          arg1_typeid = get_fn_expr_argtype(fcinfo->flinfo, 1);    Oid          arg0_elemid;    Oid          arg1_elemid;    Oid          element_type;    int16        typlen;    bool         typbyval;    char         typalign;    Datum        *elems;    bool         *nulls;    int          nelems;    Datum        cur_elem;    bool         has_nulls;    int i;        if (ARR_NDIM(v) == 0)        PG_RETURN_NULL();    else if (ARR_NDIM(v) != 1)        ereport(ERROR,            (errcode(ERRCODE_INVALID_PARAMETER_VALUE),             errmsg("idx(...) only makes sense for one-dimensional arrays, not %i", ARR_NDIM(v))));    element_type = ARR_ELEMTYPE(v);    /* For optimal performance we'd get this from a syscache or cache it in the function     * call context; see array_push in src/backend/utils/adt/array_userfuncs.c */    get_typlenbyvalalign(element_type,                         &typlen,                         &typbyval,                         &typalign);        deconstruct_array(v, element_type, typlen, typbyval, typalign, &elems, &nulls, &nelems);    has_nulls = false;    for (i = 0; i < nelems; i++)    {        has_nulls |= nulls[i];        cur_elem = elems[i];        /* Compare find_elem for equality against cur_elem */        PG_RETURN_INT(i+1);    }       if (has_nulls)        PG_RETURN_NULL();    else        PG_RETURN_INT(-1);}

/** * Convert postgres Datum into a ConcreteValue object. */AbstractValueSPtr AbstractPGValue::DatumToValue(bool inMemoryIsWritable,    Oid inTypeID, Datum inDatum) const {            // First check if datum is rowtype    if (type_is_rowtype(inTypeID)) {        HeapTupleHeader pgTuple = DatumGetHeapTupleHeader(inDatum);        return AbstractValueSPtr(new PGValue<HeapTupleHeader>(pgTuple));    } else if (type_is_array(inTypeID)) {        ArrayType *pgArray = DatumGetArrayTypeP(inDatum);                if (ARR_NDIM(pgArray) != 1)            throw std::invalid_argument("Multidimensional arrays not yet supported");                if (ARR_HASNULL(pgArray))            throw std::invalid_argument("Arrays with NULLs not yet supported");                switch (ARR_ELEMTYPE(pgArray)) {            case FLOAT8OID: {                MemHandleSPtr memoryHandle(new PGArrayHandle(pgArray));                                if (inMemoryIsWritable) {                    return AbstractValueSPtr(                        new ConcreteValue<Array<double> >(                            Array<double>(memoryHandle,                                boost::extents[ ARR_DIMS(pgArray)[0] ])                            )                        );                } else {                    return AbstractValueSPtr(                        new ConcreteValue<Array_const<double> >(                            Array_const<double>(memoryHandle,                                boost::extents[ ARR_DIMS(pgArray)[0] ])                            )                        );                }            }        }    }    switch (inTypeID) {        case BOOLOID: return AbstractValueSPtr(            new ConcreteValue<bool>( DatumGetBool(inDatum) ));        case INT2OID: return AbstractValueSPtr(            new ConcreteValue<int16_t>( DatumGetInt16(inDatum) ));        case INT4OID: return AbstractValueSPtr(            new ConcreteValue<int32_t>( DatumGetInt32(inDatum) ));        case INT8OID: return AbstractValueSPtr(            new ConcreteValue<int64_t>( DatumGetInt64(inDatum) ));        case FLOAT4OID: return AbstractValueSPtr(            new ConcreteValue<float>( DatumGetFloat4(inDatum) ));        case FLOAT8OID: return AbstractValueSPtr(            new ConcreteValue<double>( DatumGetFloat8(inDatum) ));    }        return AbstractValueSPtr();}

Datumget_power_in_range(PG_FUNCTION_ARGS){    //the size of the array we are trying to transform    int arraySize;    int power;    int32 duration;    float startRange;    float endRange;    // a Datum for the constructred and deconstructed input arrays    Datum *input_data;    // the final result to return and the input to the function    ArrayType *input;    Oid input_type;    //next 6 variables are inputted into get_typlenbyvalalign() and      int fftw_export_wisdom_to_filename(const char *filename);are used for construct and deconstruct array    //small int in postgreSQL is int16    int16 input_typelen;    bool input_typbyval;    char input_typalign;    // get input row    input = PG_GETARG_ARRAYTYPE_P(0);    // get duration    duration = PG_GETARG_INT32(1);    // get ranges    startRange = PG_GETARG_FLOAT8(2);    endRange = PG_GETARG_FLOAT8(3);    input_type = ARR_ELEMTYPE(input);    //get needed variabels    get_typlenbyvalalign(input_type, &input_typelen, &input_typbyval, &input_typalign);    // deconstruct inupt array and save the array as Datum input_data    deconstruct_array(input, input_type, input_typelen, input_typbyval, input_typalign, &input_data, NULL, &arraySize);        // set the in variable to the array we got as input.    // the real parts are from the input_data array    // the imaginary part is set to 0    power = 0;    for (int i = 0; i < arraySize; i++) {        if(startRange < i/duration && i/duration <= endRange)        {            Complex *temp = (Complex*) DatumGetPointer(input_data[i]);            power += temp->x*temp->x + temp->y*temp->y;        }    }    // free memory    pfree(input_data);    // return result    PG_RETURN_INT32(power);}

Datum welle_count( PG_FUNCTION_ARGS ){    if( PG_ARGISNULL( 0 ) )    {        PG_RETURN_NULL();    }    ArrayType * input;    input = PG_GETARG_ARRAYTYPE_P( 0 );    Datum * i_data;    Oid i_eltype;    i_eltype = ARR_ELEMTYPE( input );    int16 i_typlen;    bool  i_typbyval;    char  i_typalign;    get_typlenbyvalalign(            i_eltype,            &i_typlen,            &i_typbyval,            &i_typalign    );    bool * nulls;    int n;    deconstruct_array(            input,            i_eltype,            i_typlen,            i_typbyval,            i_typalign,            &i_data,            &nulls,            &n    );    switch( i_eltype )    {        case INT4OID:            PG_RETURN_POINTER( adeven_count_int_array( i_data, n, nulls ) );            break;        case TEXTOID:            PG_RETURN_POINTER( adeven_count_text_array( i_data, n, nulls ) );            break;        default:            elog( ERROR, "INVALID input data type" );            break;    }}

/* * fetch_array_arg_replace_nulls * * Fetch an array-valued argument; if it's null, construct an empty array * value of the proper data type.  Also cache basic element type information * in fn_extra. */static ArrayType *fetch_array_arg_replace_nulls(FunctionCallInfo fcinfo, int argno){	ArrayType  *v;	Oid			element_type;	ArrayMetaState *my_extra;	/* First collect the array value */	if (!PG_ARGISNULL(argno))	{		v = PG_GETARG_ARRAYTYPE_P(argno);		element_type = ARR_ELEMTYPE(v);	}	else	{		/* We have to look up the array type and element type */		Oid			arr_typeid = get_fn_expr_argtype(fcinfo->flinfo, argno);		if (!OidIsValid(arr_typeid))			ereport(ERROR,					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),					 errmsg("could not determine input data type")));		element_type = get_element_type(arr_typeid);		if (!OidIsValid(element_type))			ereport(ERROR,					(errcode(ERRCODE_DATATYPE_MISMATCH),					 errmsg("input data type is not an array")));		v = construct_empty_array(element_type);	}	/* Now cache required info, which might change from call to call */	my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;	if (my_extra == NULL)	{		my_extra = (ArrayMetaState *)			MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,							   sizeof(ArrayMetaState));		my_extra->element_type = InvalidOid;		fcinfo->flinfo->fn_extra = my_extra;	}	if (my_extra->element_type != element_type)	{		get_typlenbyvalalign(element_type,							 &my_extra->typlen,							 &my_extra->typbyval,							 &my_extra->typalign);		my_extra->element_type = element_type;	}	return v;}

/* * anyarray_out		- output routine for pseudo-type ANYARRAY. * * We may as well allow this, since array_out will in fact work. * XCP needs to send from data nodes to coordinator values of that type. * To be able to restore values at the destination node we need to know * actual element type. */Datumanyarray_out(PG_FUNCTION_ARGS){#ifdef XCP	/*	 * Output prefix: (type_namespace_name.typename) to look up actual element	 * type at the destination node then output in usual format for array	 */	ArrayType  *v = PG_GETARG_ARRAYTYPE_P(0);	Oid			element_type = ARR_ELEMTYPE(v);	Form_pg_type typeForm;	HeapTuple	typeTuple;	char	   *typname,			   *typnspname;	/* two identifiers, parenthesis, dot and trailing /0 */	char		prefix[2*NAMEDATALEN+4],			   *retval,			   *newval;	int 		prefixlen, retvallen;	Datum		array_out_result;	MemoryContext save_context;	save_context = MemoryContextSwitchTo(fcinfo->flinfo->fn_mcxt);	/* Figure out type name and type namespace */	typeTuple = SearchSysCache(TYPEOID,							   ObjectIdGetDatum(element_type),							   0, 0, 0);	if (!HeapTupleIsValid(typeTuple))		elog(ERROR, "cache lookup failed for type %u", element_type);	typeForm = (Form_pg_type) GETSTRUCT(typeTuple);	typname = NameStr(typeForm->typname);	typnspname = get_namespace_name(typeForm->typnamespace);	sprintf(prefix, "(%s.%s)", typnspname, typname);	ReleaseSysCache(typeTuple);	MemoryContextSwitchTo(save_context);	/* Get standard output and make up prefixed result */	array_out_result = array_out(fcinfo);	retval = DatumGetCString(array_out_result);	prefixlen = strlen(prefix);	retvallen = strlen(retval);	newval = (char *) palloc(prefixlen + retvallen + 1);	strcpy(newval, prefix);	strcpy(newval + prefixlen, retval);	pfree(retval);	PG_RETURN_CSTRING(newval);#else	return array_out(fcinfo);#endif}

Datum find_peak_power(PG_FUNCTION_ARGS){    //the size of the array we are trying to transform    int arraySize;    int peak;    // a Datum for the constructred and deconstructed input arrays    Datum *input_data;    // the final result to return and the input to the function    ArrayType *input;    Oid input_type;    //next 6 variables are inputted into get_typlenbyvalalign() and are used for construct and deconstruct array    //small int in postgreSQL is int16    int16 input_typelen;    bool input_typbyval;    char input_typalign;    // get input row    input = PG_GETARG_ARRAYTYPE_P(0);    // get input array element type    input_type = ARR_ELEMTYPE(input);    //get needed variabels    get_typlenbyvalalign(input_type, &input_typelen, &input_typbyval, &input_typalign);    // deconstruct inupt array and save the array as Datum input_data    deconstruct_array(input, input_type, input_typelen, input_typbyval, input_typalign, &input_data, NULL, &arraySize);        // set the in variable to the array we got as input.    // the real parts are from the input_data array    // the imaginary part is set to 0    peak = 0;    for (int i = 0; i < arraySize; i++) {        Complex *temp = (Complex*) DatumGetPointer(input_data[i]);        int tempValue = temp->x*temp->x + temp->y*temp->y;        if(i == 0)        {            peak = tempValue;        } else {            if(tempValue > peak){                peak = tempValue;            }        }        }    // free memory    pfree(input_data);    // return result    PG_RETURN_INT32(peak);}

/* * Transform a relation options list (list of DefElem) into the text array * format that is kept in pg_class.reloptions. * * This is used for three cases: CREATE TABLE/INDEX, ALTER TABLE SET, and * ALTER TABLE RESET.  In the ALTER cases, oldOptions is the existing * reloptions value (possibly NULL), and we replace or remove entries * as needed. * * If ignoreOids is true, then we should ignore any occurrence of "oids" * in the list (it will be or has been handled by interpretOidsOption()). * * Note that this is not responsible for determining whether the options * are valid. * * Both oldOptions and the result are text arrays (or NULL for "default"), * but we declare them as Datums to avoid including array.h in reloptions.h. */DatumtransformRelOptions(Datum oldOptions, List *defList,					bool ignoreOids, bool isReset){	Datum		result;	ArrayBuildState *astate;	ListCell   *cell;	/* no change if empty list */	if (defList == NIL)		return oldOptions;	/* We build new array using accumArrayResult */	astate = NULL;	/* Copy any oldOptions that aren't to be replaced */	if (DatumGetPointer(oldOptions) != 0)	{		ArrayType  *array = DatumGetArrayTypeP(oldOptions);		Datum	   *oldoptions;		int			noldoptions;		int			i;		Assert(ARR_ELEMTYPE(array) == TEXTOID);		deconstruct_array(array, TEXTOID, -1, false, 'i',						  &oldoptions, NULL, &noldoptions);		for (i = 0; i < noldoptions; i++)		{			text	   *oldoption = DatumGetTextP(oldoptions[i]);			char	   *text_str = VARDATA(oldoption);			int			text_len = VARSIZE(oldoption) - VARHDRSZ;			/* Search for a match in defList */			foreach(cell, defList)			{				DefElem    *def = lfirst(cell);				int			kw_len = strlen(def->defname);				if (text_len > kw_len && text_str[kw_len] == '=' &&					pg_strncasecmp(text_str, def->defname, kw_len) == 0)					break;			}			if (!cell)			{				/* No match, so keep old option */				astate = accumArrayResult(astate, oldoptions[i],										  false, TEXTOID,										  CurrentMemoryContext);			}		}

/* * UpdateCmsTopn is a helper function to add new item to CmsTopn structure. It * adds the item to the sketch, calculates its frequency, and updates the top-n * array. Finally it forms new CmsTopn from updated sketch and updated top-n array. */static CmsTopn *UpdateCmsTopn(CmsTopn *currentCmsTopn, Datum newItem,              TypeCacheEntry *newItemTypeCacheEntry){	CmsTopn *updatedCmsTopn = NULL;	ArrayType *currentTopnArray = NULL;	ArrayType *updatedTopnArray = NULL;	Datum detoastedItem = 0;	Oid newItemType = newItemTypeCacheEntry->type_id;	Oid currentItemType = InvalidOid;	Frequency newItemFrequency = 0;	bool topnArrayUpdated = false;	Size currentTopnArrayLength = 0;	currentTopnArray = TopnArray(currentCmsTopn);	currentTopnArrayLength = ARR_DIMS(currentTopnArray)[0];	currentItemType = ARR_ELEMTYPE(currentTopnArray);	if (currentTopnArrayLength != 0 && currentItemType != newItemType)	{		ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE),		                errmsg("not proper type for this cms_topn")));	}	/* if datum is toasted, detoast it */	if (newItemTypeCacheEntry->typlen == -1)	{		detoastedItem = PointerGetDatum(PG_DETOAST_DATUM(newItem));	}	else	{		detoastedItem = newItem;	}	newItemFrequency = UpdateSketchInPlace(currentCmsTopn, detoastedItem,	                                       newItemTypeCacheEntry);	updatedTopnArray = UpdateTopnArray(currentCmsTopn, detoastedItem,	                                   newItemTypeCacheEntry, newItemFrequency,	                                   &topnArrayUpdated);	/* we only form a new CmsTopn only if top-n array is updated */	if (topnArrayUpdated)	{		updatedCmsTopn = FormCmsTopn(currentCmsTopn, updatedTopnArray);	}	else	{		updatedCmsTopn = currentCmsTopn;	}	return updatedCmsTopn;}

/* * Turn an array into JSON. */static voidarray_to_json_internal(Datum array, StringInfo result, bool use_line_feeds){	ArrayType  *v = DatumGetArrayTypeP(array);	Oid			element_type = ARR_ELEMTYPE(v);	int		   *dim;	int			ndim;	int			nitems;	int         count = 0;	Datum	   *elements;	bool       *nulls;	int16		typlen;	bool		typbyval;	char		typalign,				typdelim;	Oid			typioparam;	Oid			typoutputfunc;	TYPCATEGORY tcategory;	ndim = ARR_NDIM(v);	dim = ARR_DIMS(v);	nitems = ArrayGetNItems(ndim, dim);	if (nitems <= 0)	{		appendStringInfoString(result,"[]");		return;	}	get_type_io_data(element_type, IOFunc_output,					 &typlen, &typbyval, &typalign,					 &typdelim, &typioparam, &typoutputfunc);	deconstruct_array(v, element_type, typlen, typbyval,					  typalign, &elements, &nulls,					  &nitems);	if (element_type == RECORDOID)		tcategory = TYPCATEGORY_COMPOSITE;	else if (element_type == JSONOID)		tcategory = TYPCATEGORY_JSON;	else		tcategory = TypeCategory(element_type);	array_dim_to_json(result, 0, ndim, dim, elements, &count, tcategory,					  typoutputfunc, use_line_feeds);	pfree(elements);	pfree(nulls);}

static float8 *check_float8_array(ArrayType *transarray, const char *caller){	/*	 * We expect the input to be a 3-element float array; verify that. We	 * don't need to use deconstruct_array() since the array data is just	 * going to look like a C array of 3 float8 values.	 */	if (ARR_NDIM(transarray) != 1 ||		ARR_DIMS(transarray)[0] != 3 ||		ARR_ELEMTYPE(transarray) != FLOAT8OID)		elog(ERROR, "%s: expected 3-element float8 array", caller);	return (float8 *) ARR_DATA_PTR(transarray);}

Datuminternal_get_array_of_close_canopies(PG_FUNCTION_ARGS){    SvecType       *svec;    Datum          *all_canopies;    int             num_all_canopies;    float8          threshold;    PGFunction      metric_fn;        ArrayType      *close_canopies_arr;    int4           *close_canopies;    int             num_close_canopies;    size_t          bytes;    MemoryContext   mem_context_for_function_calls;        svec = PG_GETARG_SVECTYPE_P(verify_arg_nonnull(fcinfo, 0));    get_svec_array_elms(PG_GETARG_ARRAYTYPE_P(verify_arg_nonnull(fcinfo, 1)),        &all_canopies, &num_all_canopies);    threshold = PG_GETARG_FLOAT8(verify_arg_nonnull(fcinfo, 2));    metric_fn = get_metric_fn(PG_GETARG_INT32(verify_arg_nonnull(fcinfo, 3)));        mem_context_for_function_calls = setup_mem_context_for_functional_calls();    close_canopies = (int4 *) palloc(sizeof(int4) * num_all_canopies);    num_close_canopies = 0;    for (int i = 0; i < num_all_canopies; i++) {        if (compute_metric(metric_fn, mem_context_for_function_calls,                PointerGetDatum(svec), all_canopies[i]) < threshold)            close_canopies[num_close_canopies++] = i + 1 /* lower bound */;    }    MemoryContextDelete(mem_context_for_function_calls);    /* If we cannot find any close canopy, return NULL. Note that the result     * we return will be passed to internal_kmeans_closest_centroid() and if the     * array of close canopies is NULL, then internal_kmeans_closest_centroid()     * will consider and compute the distance to all centroids. */    if (num_close_canopies == 0)        PG_RETURN_NULL();    bytes = ARR_OVERHEAD_NONULLS(1) + sizeof(int4) * num_close_canopies;    close_canopies_arr = (ArrayType *) palloc0(bytes);    SET_VARSIZE(close_canopies_arr, bytes);    ARR_ELEMTYPE(close_canopies_arr) = INT4OID;    ARR_NDIM(close_canopies_arr) = 1;    ARR_DIMS(close_canopies_arr)[0] = num_close_canopies;    ARR_LBOUND(close_canopies_arr)[0] = 1;    memcpy(ARR_DATA_PTR(close_canopies_arr), close_canopies,        sizeof(int4) * num_close_canopies);    PG_RETURN_ARRAYTYPE_P(close_canopies_arr);}

staticinlinevoidget_svec_array_elms(ArrayType *inArrayType, Datum **outSvecArr, int *outLen){    deconstruct_array(inArrayType,           /* array */                  ARR_ELEMTYPE(inArrayType), /* elmtype */                  -1,                        /* elmlen */                  false,                     /* elmbyval */                  'd',                       /* elmalign */                  outSvecArr,                /* elemsp */                  NULL,                      /* nullsp -- pass NULL, because we                                                 don't support NULLs */                  outLen);                   /* nelemsp */}