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

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

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

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

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

/* * 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 ArrayType *intArrayInit(int ndims, int const * dims, int const * lbs){    ArrayType * res;    int size;    int nbytes;    if (ndims < 0)              /* we do allow zero-dimension arrays */        ereport(ERROR,                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),                 errmsg("invalid number of dimensions: %d", ndims)));    if (ndims > MAXDIM)        ereport(ERROR,                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),                 errmsg("number of array dimensions (%d) exceeds the maximum allowed (%d)",                        ndims, MAXDIM)));        /* fast track for empty array */    if (ndims == 0)        return construct_empty_array(INT4OID);        size = ArrayGetNItems(ndims, dims);    nbytes = ARR_OVERHEAD_NONULLS(ndims);    nbytes += size * 4;    res = palloc0(nbytes);    SET_VARSIZE(res, nbytes);    res->ndim = ndims;    res->elemtype = INT4OID;    res->dataoffset = 0;    memcpy(ARR_DIMS(res), dims, ndims * sizeof(int));    memcpy(ARR_LBOUND(res), lbs, ndims * sizeof(int));    return 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 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");}

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

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

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

/* * The final function for aggregating the class counts for REP. It takes the class * count array produced by the sfunc and produces a two-element array. The first * element is the ID of the class that has the maximum number of cases represented by * the root node of the subtree being processed. The second element is the number of * reduced misclassified cases if the leave nodes of the subtree are pruned. * * Parameters: *      class_count_data:   The array containing all the information for the  *                          calculation of Reduced-Error pruning.  * Return: *      A two element array. */Datum rep_aggr_class_count_ffunc(PG_FUNCTION_ARGS){    ArrayType *class_count_array    = PG_GETARG_ARRAYTYPE_P(0);    int array_dim                   = ARR_NDIM(class_count_array);    check_error_value		(			array_dim == 1,			"invalid array dimension: %d. The dimension of class count array must be equal to 1",			array_dim		);    int *p_array_dim                = ARR_DIMS(class_count_array);    int array_length                = ArrayGetNItems(array_dim,p_array_dim);    int64 *class_count_data         = (int64 *)ARR_DATA_PTR(class_count_array);    int64 *result                   = palloc(sizeof(int64)*2);    check_error		(			result,			"memory allocation failure"		);    int64 max = class_count_data[1];    int64 sum = max;    int maxid = 1;    for(int i = 2; i < array_length; ++i)    {        if(max < class_count_data[i])        {            max = class_count_data[i];            maxid = i;        }        sum += class_count_data[i];    }    /* maxid is the id of the class, which has the most cases */    result[0] = maxid;    /*     * (sum - max) is the number of mis-classified cases represented by     * the root node of the subtree being processed     * class_count_data[0] the total number of mis-classified cases     */    result[1] = class_count_data[0] - (sum - max);    ArrayType* result_array =    	construct_array(         (Datum *)result,         2,         INT8OID,         sizeof(int64),         true,         'd'        );    PG_RETURN_ARRAYTYPE_P(result_array);}

/* * get_flat_size method for expanded arrays */static SizeEA_get_flat_size(ExpandedObjectHeader *eohptr){	ExpandedArrayHeader *eah = (ExpandedArrayHeader *) eohptr;	int			nelems;	int			ndims;	Datum	   *dvalues;	bool	   *dnulls;	Size		nbytes;	int			i;	Assert(eah->ea_magic == EA_MAGIC);	/* Easy if we have a valid flattened value */	if (eah->fvalue)		return ARR_SIZE(eah->fvalue);	/* If we have a cached size value, believe that */	if (eah->flat_size)		return eah->flat_size;	/*	 * Compute space needed by examining dvalues/dnulls.  Note that the result	 * array will have a nulls bitmap if dnulls isn't NULL, even if the array	 * doesn't actually contain any nulls now.	 */	nelems = eah->nelems;	ndims = eah->ndims;	Assert(nelems == ArrayGetNItems(ndims, eah->dims));	dvalues = eah->dvalues;	dnulls = eah->dnulls;	nbytes = 0;	for (i = 0; i < nelems; i++)	{		if (dnulls && dnulls[i])			continue;		nbytes = att_addlength_datum(nbytes, eah->typlen, dvalues[i]);		nbytes = att_align_nominal(nbytes, eah->typalign);		/* check for overflow of total request */		if (!AllocSizeIsValid(nbytes))			ereport(ERROR,					(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),					 errmsg("array size exceeds the maximum allowed (%d)",							(int) MaxAllocSize)));	}	if (dnulls)		nbytes += ARR_OVERHEAD_WITHNULLS(ndims, nelems);	else		nbytes += ARR_OVERHEAD_NONULLS(ndims);	/* cache for next time */	eah->flat_size = nbytes;	return nbytes;}

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

Datuminternal_kmeans_agg_centroid_merge(PG_FUNCTION_ARGS) {    /* This function is declared as strict. No checking null here. */    ArrayType       *array = NULL;    ArrayType       *array2 = NULL;        if (fcinfo->context && IsA(fcinfo->context, AggState))        array = PG_GETARG_ARRAYTYPE_P(0);    else        array = PG_GETARG_ARRAYTYPE_P_COPY(0);                int array_dim = ARR_NDIM(array);    int *p_array_dim = ARR_DIMS(array);    int array_length = ArrayGetNItems(array_dim, p_array_dim);    array2 = PG_GETARG_ARRAYTYPE_P(1);    array_dim = ARR_NDIM(array2);    p_array_dim = ARR_DIMS(array2);    int array2_length = ArrayGetNItems(array_dim, p_array_dim);    if (array_length != array2_length)    {        ereport(ERROR,                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),                 errmsg("function /"%s/", Inconsistent array length. "                    "first: %d, second:%d",                    format_procedure(fcinfo->flinfo->fn_oid),                     array_length, array2_length)));    }    float8* c_array = (float8 *)ARR_DATA_PTR(array);    float8* c_array2 = (float8 *)ARR_DATA_PTR(array2);    for(int i=0; i<array_length; i++)    {        c_array[i]+= c_array2[i];    }    PG_RETURN_ARRAYTYPE_P(array);}

Datum_ltree_compress(PG_FUNCTION_ARGS){	GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);	GISTENTRY  *retval = entry;	if (entry->leafkey)	{							/* ltree */		ltree_gist *key;		ArrayType  *val = DatumGetArrayTypeP(entry->key);		int4		len = LTG_HDRSIZE + ASIGLEN;		int			num = ArrayGetNItems(ARR_NDIM(val), ARR_DIMS(val));		ltree	   *item = (ltree *) ARR_DATA_PTR(val);		if (ARR_NDIM(val) != 1)			ereport(ERROR,					(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),					 errmsg("array must be one-dimensional")));		key = (ltree_gist *) palloc(len);		key->len = len;		key->flag = 0;		MemSet(LTG_SIGN(key), 0, ASIGLEN);		while (num > 0)		{			hashing(LTG_SIGN(key), item);			num--;			item = NEXTVAL(item);		}		retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));		gistentryinit(*retval, PointerGetDatum(key),					  entry->rel, entry->page,					  entry->offset, key->len, FALSE);	}	else if (!LTG_ISALLTRUE(entry->key))	{		int4		i,					len;		ltree_gist *key;		BITVECP		sign = LTG_SIGN(DatumGetPointer(entry->key));		ALOOPBYTE(				  if ((sign[i] & 0xff) != 0xff)				  PG_RETURN_POINTER(retval);		);

/* * Turn an array into JSON. */static voidarray_to_jsonb_internal(Datum array, JsonbInState *result){	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;	JsonbTypeCategory tcategory;	Oid			outfuncoid;	ndim = ARR_NDIM(v);	dim = ARR_DIMS(v);	nitems = ArrayGetNItems(ndim, dim);	if (nitems <= 0)	{		result->res = pushJsonbValue(&result->parseState, WJB_BEGIN_ARRAY, NULL);		result->res = pushJsonbValue(&result->parseState, WJB_END_ARRAY, NULL);		return;	}	get_typlenbyvalalign(element_type,						 &typlen, &typbyval, &typalign);	jsonb_categorize_type(element_type,						  &tcategory, &outfuncoid);	deconstruct_array(v, element_type, typlen, typbyval,					  typalign, &elements, &nulls,					  &nitems);	array_dim_to_jsonb(result, 0, ndim, dim, elements, nulls, &count, tcategory,					   outfuncoid);	pfree(elements);	pfree(nulls);}

Datum pc_typmod_in(PG_FUNCTION_ARGS){	uint32 typmod = 0;	Datum *elem_values;	int n = 0;	int i = 0;	ArrayType *arr = (ArrayType *) DatumGetPointer(PG_GETARG_DATUM(0));	if (ARR_ELEMTYPE(arr) != CSTRINGOID)		ereport(ERROR,		        (errcode(ERRCODE_ARRAY_ELEMENT_ERROR),		         errmsg("typmod array must be type cstring[]")));	if (ARR_NDIM(arr) != 1)		ereport(ERROR,		        (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),		         errmsg("typmod array must be one-dimensional")));	if (ARR_HASNULL(arr))		ereport(ERROR,		        (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),		         errmsg("typmod array must not contain nulls")));	if (ArrayGetNItems(ARR_NDIM(arr), ARR_DIMS(arr)) > 1)		ereport(ERROR,		        (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),		         errmsg("typmod array must have one element")));	deconstruct_array(arr,	                  CSTRINGOID, -2, false, 'c', /* hardwire cstring representation details */	                  &elem_values, NULL, &n);	for (i = 0; i < n; i++)	{		if ( i == 0 ) /* PCID */		{			char *s = DatumGetCString(elem_values[i]);			typmod = pg_atoi(s, sizeof(int32), '/0');		}	}	PG_RETURN_INT32(typmod);}

Datum hash_array( PG_FUNCTION_ARGS){	ArrayType *state  = PG_GETARG_ARRAYTYPE_P(0);	int dimstate = ARR_NDIM(state);    int *dimsstate = ARR_DIMS(state);	int numstate = ArrayGetNItems(dimstate,dimsstate);    int32 *vals_state=(int32 *)ARR_DATA_PTR(state);	    unsigned long hash = 65599;    unsigned short c;    int i = 0;        for (;i<numstate;i++)	{		c = vals_state[i];		hash = c + (hash << 7) + (hash << 16) - hash;	}	PG_RETURN_INT32(hash);}

Datumginarrayconsistent(PG_FUNCTION_ARGS){	bool	   *check = (bool *) PG_GETARG_POINTER(0);	StrategyNumber strategy = PG_GETARG_UINT16(1);	ArrayType  *query = PG_GETARG_ARRAYTYPE_P(2);	int			res,				i,				nentries;	/* ARRAYCHECK was already done by previous ginarrayextract call */	switch (strategy)	{		case GinOverlapStrategy:		case GinContainedStrategy:			/* at least one element in check[] is true, so result = true */			res = TRUE;			break;		case GinContainsStrategy:		case GinEqualStrategy:			nentries = ArrayGetNItems(ARR_NDIM(query), ARR_DIMS(query));			res = TRUE;			for (i = 0; i < nentries; i++)				if (!check[i])				{					res = FALSE;					break;				}			break;		default:			elog(ERROR, "ginarrayconsistent: unknown strategy number: %d",				 strategy);			res = FALSE;	}	PG_RETURN_BOOL(res);}

static float *getWeights(ArrayType *win){	static float ws[lengthof(weights)];	int			i;	float4	   *arrdata;	if (win == NULL)		return weights;	if (ARR_NDIM(win) != 1)		ereport(ERROR,				(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),				 errmsg("array of weight must be one-dimensional")));	if (ArrayGetNItems(ARR_NDIM(win), ARR_DIMS(win)) < lengthof(weights))		ereport(ERROR,				(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),				 errmsg("array of weight is too short")));	if (array_contains_nulls(win))		ereport(ERROR,				(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),				 errmsg("array of weight must not contain nulls")));	arrdata = (float4 *) ARR_DATA_PTR(win);	for (i = 0; i < lengthof(weights); i++)	{		ws[i] = (arrdata[i] >= 0) ? arrdata[i] : weights[i];		if (ws[i] > 1.0)			ereport(ERROR,					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),					 errmsg("weight out of range")));	}	return ws;}

Datum aggr_InfoGain(PG_FUNCTION_ARGS) {	ArrayType *state  = PG_GETARG_ARRAYTYPE_P(0);	int dimstate = ARR_NDIM(state);    int *dimsstate = ARR_DIMS(state);	int numstate = ArrayGetNItems(dimstate,dimsstate);    float8 *vals_state=(float8 *)ARR_DATA_PTR(state);    	float8 truevalue = PG_GETARG_FLOAT8(1);	float8 trueweight = PG_GETARG_FLOAT8(2);	int32 posclasses = PG_GETARG_INT32(3);	int32 trueclass = PG_GETARG_INT32(5);   	ArrayType *pgarray;	vals_state[0] += trueweight;	vals_state[trueclass] += trueweight;		vals_state[(int)(truevalue*(posclasses+1))] += trueweight;	vals_state[(int)(truevalue*(posclasses+1) + trueclass)] += trueweight;      pgarray = construct_array((Datum *)vals_state,		numstate,FLOAT8OID,		sizeof(float8),true,'d');    PG_RETURN_ARRAYTYPE_P(pgarray);}

//.........这里部分代码省略.........	/*	 * short circuit - if one input array is empty, and the other is not, we	 * return the non-empty one as the result	 *	 * if both are empty, return the first one	 */	if (ndims1 == 0 && ndims2 > 0)		PG_RETURN_ARRAYTYPE_P(v2);	if (ndims2 == 0)		PG_RETURN_ARRAYTYPE_P(v1);	/* the rest fall under rule 3, 4, or 5 */	if (ndims1 != ndims2 &&		ndims1 != ndims2 - 1 &&		ndims1 != ndims2 + 1)		ereport(ERROR,				(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),				 errmsg("cannot concatenate incompatible arrays"),				 errdetail("Arrays of %d and %d dimensions are not "						   "compatible for concatenation.",						   ndims1, ndims2)));	/* get argument array details */	lbs1 = ARR_LBOUND(v1);	lbs2 = ARR_LBOUND(v2);	dims1 = ARR_DIMS(v1);	dims2 = ARR_DIMS(v2);	dat1 = ARR_DATA_PTR(v1);	dat2 = ARR_DATA_PTR(v2);	bitmap1 = ARR_NULLBITMAP(v1);	bitmap2 = ARR_NULLBITMAP(v2);	nitems1 = ArrayGetNItems(ndims1, dims1);	nitems2 = ArrayGetNItems(ndims2, dims2);	ndatabytes1 = ARR_SIZE(v1) - ARR_DATA_OFFSET(v1);	ndatabytes2 = ARR_SIZE(v2) - ARR_DATA_OFFSET(v2);	if (ndims1 == ndims2)	{		/*		 * resulting array is made up of the elements (possibly arrays		 * themselves) of the input argument arrays		 */		ndims = ndims1;		dims = (int *) palloc(ndims * sizeof(int));		lbs = (int *) palloc(ndims * sizeof(int));		dims[0] = dims1[0] + dims2[0];		lbs[0] = lbs1[0];		for (i = 1; i < ndims; i++)		{			if (dims1[i] != dims2[i] || lbs1[i] != lbs2[i])				ereport(ERROR,						(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),						 errmsg("cannot concatenate incompatible arrays"),					errdetail("Arrays with differing element dimensions are "							  "not compatible for concatenation.")));			dims[i] = dims1[i];			lbs[i] = lbs1[i];		}	}	else if (ndims1 == ndims2 - 1)	{

Datumrewrite_accum(PG_FUNCTION_ARGS){	QUERYTYPE  *acc = (QUERYTYPE *) PG_GETARG_POINTER(0);	ArrayType  *qa = (ArrayType *) DatumGetPointer(PG_DETOAST_DATUM_COPY(PG_GETARG_DATUM(1)));	QUERYTYPE  *q;	QTNode	   *qex,			   *subs = NULL,			   *acctree;	bool		isfind = false;	Datum	   *elemsp;	int			nelemsp;	AggregateContext = ((AggState *) fcinfo->context)->aggcontext;	if (acc == NULL || PG_ARGISNULL(0))	{		acc = (QUERYTYPE *) MEMALLOC(AggMemory, sizeof(QUERYTYPE));		acc->len = HDRSIZEQT;		acc->size = 0;	}	if (qa == NULL || PG_ARGISNULL(1))	{		PG_FREE_IF_COPY(qa, 1);		PG_RETURN_POINTER(acc);	}	if (ARR_NDIM(qa) != 1)		elog(ERROR, "array must be one-dimensional, not %d dimension", ARR_NDIM(qa));	if (ArrayGetNItems(ARR_NDIM(qa), ARR_DIMS(qa)) != 3)		elog(ERROR, "array should have only three elements");	if (tsqOid == InvalidOid)	{		SPI_connect();		get_tsq_Oid();		SPI_finish();	}	if (ARR_ELEMTYPE(qa) != tsqOid)		elog(ERROR, "array should contain tsquery type");	deconstruct_array(qa, tsqOid, -1, false, 'i', &elemsp, NULL, &nelemsp);	q = (QUERYTYPE *) DatumGetPointer(elemsp[0]);	if (q->size == 0)	{		pfree(elemsp);		PG_RETURN_POINTER(acc);	}	if (!acc->size)	{		if (acc->len > HDRSIZEQT)		{			pfree(elemsp);			PG_RETURN_POINTER(acc);		}		else			acctree = QT2QTN(GETQUERY(q), GETOPERAND(q));	}	else		acctree = QT2QTN(GETQUERY(acc), GETOPERAND(acc));	QTNTernary(acctree);	QTNSort(acctree);	q = (QUERYTYPE *) DatumGetPointer(elemsp[1]);	if (q->size == 0)	{		pfree(elemsp);		PG_RETURN_POINTER(acc);	}	qex = QT2QTN(GETQUERY(q), GETOPERAND(q));	QTNTernary(qex);	QTNSort(qex);	q = (QUERYTYPE *) DatumGetPointer(elemsp[2]);	if (q->size)		subs = QT2QTN(GETQUERY(q), GETOPERAND(q));	acctree = findsubquery(acctree, qex, PlainMemory, subs, &isfind);	if (isfind || !acc->size)	{		/* pfree( acc ); do not pfree(p), because nodeAgg.c will */		if (acctree)		{			QTNBinary(acctree);			acc = QTN2QT(acctree, AggMemory);		}		else		{			acc = (QUERYTYPE *) MEMALLOC(AggMemory, HDRSIZEQT * 2);			acc->len = HDRSIZEQT * 2;			acc->size = 0;		}	}//.........这里部分代码省略.........

Datuminternal_kmeans_agg_centroid_trans(PG_FUNCTION_ARGS) {    ArrayType       *array = NULL;    ArrayType       *cent_array = NULL;    int32           dimension;    int32           num_of_centroids;    int32           centroid_index;    bool            rebuild_array = false;    int32           expected_array_len;        float8          *c_array = NULL;    cent_array = PG_GETARG_ARRAYTYPE_P(verify_arg_nonnull(fcinfo, 1));    int array_dim = ARR_NDIM(cent_array);    int *p_array_dim = ARR_DIMS(cent_array);    int array_length = ArrayGetNItems(array_dim, p_array_dim);    float8* c_cent_array = (float8 *)ARR_DATA_PTR(cent_array);    dimension = PG_GETARG_INT32(verify_arg_nonnull(fcinfo, 2));    num_of_centroids = PG_GETARG_INT32(verify_arg_nonnull(fcinfo, 3));    centroid_index = PG_GETARG_INT32(verify_arg_nonnull(fcinfo, 4));        expected_array_len = num_of_centroids*dimension;    if (dimension < 1)    {        ereport(ERROR,                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),                 errmsg("function /"%s/", Invalid dimension:%d",                    format_procedure(fcinfo->flinfo->fn_oid),                     dimension)));    }    if (array_length != dimension)    {        ereport(ERROR,                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),                 errmsg("function /"%s/", Inconsistent Dimension. "                     "Expected:%d, Actual:%d",                    format_procedure(fcinfo->flinfo->fn_oid),                     dimension, array_length)));    }    if (num_of_centroids < 1)    {        ereport(ERROR,                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),                 errmsg("function /"%s/", Invalid num_of_centroids:%d",                    format_procedure(fcinfo->flinfo->fn_oid),                     num_of_centroids)));    }    if (centroid_index < 1 || centroid_index>num_of_centroids)    {        ereport(ERROR,                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),                 errmsg("function /"%s/", Invalid centroid_index:%d",                    format_procedure(fcinfo->flinfo->fn_oid),                     centroid_index)));    }    if (PG_ARGISNULL(0))    {        c_array = palloc0(expected_array_len*sizeof(float8));        rebuild_array = true;    }    else    {        if (fcinfo->context && IsA(fcinfo->context, AggState))            array = PG_GETARG_ARRAYTYPE_P(0);        else            array = PG_GETARG_ARRAYTYPE_P_COPY(0);                        array_dim = ARR_NDIM(array);        p_array_dim = ARR_DIMS(array);        array_length = ArrayGetNItems(array_dim, p_array_dim);        if (array_length != expected_array_len)        {            ereport(ERROR,                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),                     errmsg("function /"%s/", Invalid array length. "                        "Expected: %d, Actual:%d",                        format_procedure(fcinfo->flinfo->fn_oid),                         expected_array_len, array_length)));        }        c_array = (float8 *)ARR_DATA_PTR(array);    }            float8 * data_ptr = c_array+(centroid_index-1)*dimension;    for(int index=0; index<dimension; index++)    {        data_ptr[index] = c_cent_array[index];    }        if (rebuild_array)    {        /* construct a new array to keep the aggr states. */        array =//.........这里部分代码省略.........

Datuminternal_kmeans_closest_centroid(PG_FUNCTION_ARGS) {    ArrayType      *point_array;    ArrayType      *centroids_array;    float8          distance, min_distance = INFINITY;    int             closest_centroid = 0;    int             cid;    point_array = PG_GETARG_ARRAYTYPE_P(verify_arg_nonnull(fcinfo, 0));    float8* c_point_array = (float8 *)ARR_DATA_PTR(point_array);    centroids_array = PG_GETARG_ARRAYTYPE_P(verify_arg_nonnull(fcinfo, 1));    float8* c_centroids_array = (float8 *)ARR_DATA_PTR(centroids_array);    int dimension = PG_GETARG_INT32(verify_arg_nonnull(fcinfo, 2));    int num_of_centroids = PG_GETARG_INT32(verify_arg_nonnull(fcinfo, 3));     int centroids_array_len = num_of_centroids*dimension;    int dist_metric = PG_GETARG_INT32(verify_arg_nonnull(fcinfo, 4));     ArrayType      *canopy_ids_arr = NULL;    int4           *canopy_ids = NULL;    bool            indirect;    if (PG_ARGISNULL(5))     {        indirect = false;    }     else     {        indirect = true;        canopy_ids_arr = PG_GETARG_ARRAYTYPE_P(5);        /* There should always be a close canopy, but let's be on the safe side. */        if (ARR_NDIM(canopy_ids_arr) == 0)            ereport(ERROR,                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),                 errmsg("internal error: array of close canopies cannot be empty")));        canopy_ids = (int4*) ARR_DATA_PTR(canopy_ids_arr);        num_of_centroids = ARR_DIMS(canopy_ids_arr)[0];    }    if (dimension < 1)    {        ereport(ERROR,                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),                 errmsg("function /"%s/", Invalid dimension:%d",                    format_procedure(fcinfo->flinfo->fn_oid),                     dimension)));    }    if (num_of_centroids < 1)    {        ereport(ERROR,                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),                 errmsg("function /"%s/", Invalid num_of_centroids:%d",                    format_procedure(fcinfo->flinfo->fn_oid),                     num_of_centroids)));    }    int array_dim = ARR_NDIM(point_array);    int *p_array_dim = ARR_DIMS(point_array);    int array_length = ArrayGetNItems(array_dim, p_array_dim);    if (array_length != dimension)    {        ereport(ERROR,                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),                 errmsg("function /"%s/", Invalid point array length. "                    "Expected: %d, Actual:%d",                    format_procedure(fcinfo->flinfo->fn_oid),                     dimension, array_length)));    }    array_dim = ARR_NDIM(centroids_array);    p_array_dim = ARR_DIMS(centroids_array);    array_length = ArrayGetNItems(array_dim, p_array_dim);    if (array_length != centroids_array_len)    {        ereport(ERROR,                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),                 errmsg("function /"%s/", Invalid centroids array length. "                    "Expected: %d, Actual:%d",                    format_procedure(fcinfo->flinfo->fn_oid),                     centroids_array_len, array_length)));    }    for (int i = 0; i< num_of_centroids; i++)     {        cid = indirect ? canopy_ids[i] - ARR_LBOUND(canopy_ids_arr)[0] : i;	    double * centroid = c_centroids_array+cid*dimension;                MetricFunc func = get_metric_fn_for_array(dist_metric);        distance = (*func)(centroid, c_point_array, dimension);        if (distance < min_distance) {            closest_centroid = cid;            min_distance = distance;        }    }        PG_RETURN_INT32(closest_centroid+ARR_LBOUND(centroids_array)[0]);//.........这里部分代码省略.........

/* * 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;	Oid			castfunc = InvalidOid;	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);	if (element_type > FirstNormalObjectId)	{		HeapTuple	tuple;		Form_pg_cast castForm;		tuple = SearchSysCache2(CASTSOURCETARGET,								ObjectIdGetDatum(element_type),								ObjectIdGetDatum(JSONOID));		if (HeapTupleIsValid(tuple))		{			castForm = (Form_pg_cast) GETSTRUCT(tuple);			if (castForm->castmethod == COERCION_METHOD_FUNCTION)				castfunc = typoutputfunc = castForm->castfunc;			ReleaseSysCache(tuple);		}	}	deconstruct_array(v, element_type, typlen, typbyval,					  typalign, &elements, &nulls,					  &nitems);	if (castfunc != InvalidOid)		tcategory = TYPCATEGORY_JSON_CAST;	else 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, nulls, &count, tcategory,					  typoutputfunc, use_line_feeds);	pfree(elements);	pfree(nulls);}

Datumtsa_rewrite_accum(PG_FUNCTION_ARGS){	TSQuery		acc;	ArrayType  *qa;	TSQuery		q;	QTNode	   *qex = NULL,			   *subs = NULL,			   *acctree = NULL;	bool		isfind = false;	Datum	   *elemsp;	int			nelemsp;	MemoryContext aggcontext;	MemoryContext oldcontext;	aggcontext = ((AggState *) fcinfo->context)->aggcontext;	if (PG_ARGISNULL(0) || PG_GETARG_POINTER(0) == NULL)	{		acc = (TSQuery) MemoryContextAlloc(aggcontext, HDRSIZETQ);		SET_VARSIZE(acc, HDRSIZETQ);		acc->size = 0;	}	else		acc = PG_GETARG_TSQUERY(0);	if (PG_ARGISNULL(1) || PG_GETARG_POINTER(1) == NULL)		PG_RETURN_TSQUERY(acc);	else		qa = PG_GETARG_ARRAYTYPE_P_COPY(1);	if (ARR_NDIM(qa) != 1)		elog(ERROR, "array must be one-dimensional, not %d dimensions",			 ARR_NDIM(qa));	if (ArrayGetNItems(ARR_NDIM(qa), ARR_DIMS(qa)) != 3)		elog(ERROR, "array must have three elements");	if (ARR_ELEMTYPE(qa) != TSQUERYOID)		elog(ERROR, "array must contain tsquery elements");	deconstruct_array(qa, TSQUERYOID, -1, false, 'i', &elemsp, NULL, &nelemsp);	q = DatumGetTSQuery(elemsp[0]);	if (q->size == 0)	{		pfree(elemsp);		PG_RETURN_POINTER(acc);	}	if (!acc->size)	{		if (VARSIZE(acc) > HDRSIZETQ)		{			pfree(elemsp);			PG_RETURN_POINTER(acc);		}		else			acctree = QT2QTN(GETQUERY(q), GETOPERAND(q));	}	else		acctree = QT2QTN(GETQUERY(acc), GETOPERAND(acc));	QTNTernary(acctree);	QTNSort(acctree);	q = DatumGetTSQuery(elemsp[1]);	if (q->size == 0)	{		pfree(elemsp);		PG_RETURN_POINTER(acc);	}	qex = QT2QTN(GETQUERY(q), GETOPERAND(q));	QTNTernary(qex);	QTNSort(qex);	q = DatumGetTSQuery(elemsp[2]);	if (q->size)		subs = QT2QTN(GETQUERY(q), GETOPERAND(q));	acctree = findsubquery(acctree, qex, subs, &isfind);	if (isfind || !acc->size)	{		/* pfree( acc ); do not pfree(p), because nodeAgg.c will */		if (acctree)		{			QTNBinary(acctree);			oldcontext = MemoryContextSwitchTo(aggcontext);			acc = QTN2QT(acctree);			MemoryContextSwitchTo(oldcontext);		}		else		{			acc = (TSQuery) MemoryContextAlloc(aggcontext, HDRSIZETQ);			SET_VARSIZE(acc, HDRSIZETQ);			acc->size = 0;		}	}	pfree(elemsp);	QTNFree(qex);//.........这里部分代码省略.........

/* * Common subroutine for num_nulls() and num_nonnulls(). * Returns TRUE if successful, FALSE if function should return NULL. * If successful, total argument count and number of nulls are * returned into *nargs and *nulls. */static boolcount_nulls(FunctionCallInfo fcinfo,			int32 *nargs, int32 *nulls){	int32		count = 0;	int			i;	/* Did we get a VARIADIC array argument, or separate arguments? */	if (get_fn_expr_variadic(fcinfo->flinfo))	{		ArrayType  *arr;		int			ndims,					nitems,				   *dims;		bits8	   *bitmap;		Assert(PG_NARGS() == 1);		/*		 * If we get a null as VARIADIC array argument, we can't say anything		 * useful about the number of elements, so return NULL.  This behavior		 * is consistent with other variadic functions - see concat_internal.		 */		if (PG_ARGISNULL(0))			return false;		/*		 * Non-null argument had better be an array.  We assume that any call		 * context that could let get_fn_expr_variadic return true will have		 * checked that a VARIADIC-labeled parameter actually is an array.  So		 * it should be okay to just Assert that it's an array rather than		 * doing a full-fledged error check.		 */		Assert(OidIsValid(get_base_element_type(get_fn_expr_argtype(fcinfo->flinfo, 0))));		/* OK, safe to fetch the array value */		arr = PG_GETARG_ARRAYTYPE_P(0);		/* Count the array elements */		ndims = ARR_NDIM(arr);		dims = ARR_DIMS(arr);		nitems = ArrayGetNItems(ndims, dims);		/* Count those that are NULL */		bitmap = ARR_NULLBITMAP(arr);		if (bitmap)		{			int			bitmask = 1;			for (i = 0; i < nitems; i++)			{				if ((*bitmap & bitmask) == 0)					count++;				bitmask <<= 1;				if (bitmask == 0x100)				{					bitmap++;					bitmask = 1;				}			}		}		*nargs = nitems;		*nulls = count;	}	else	{		/* Separate arguments, so just count 'em */		for (i = 0; i < PG_NARGS(); i++)		{			if (PG_ARGISNULL(i))				count++;		}		*nargs = PG_NARGS();		*nulls = count;	}	return true;}