Skip to content
Snippets Groups Projects
Select Git revision
  • benchmark-tools
  • postgres-lambda
  • master default
  • REL9_4_25
  • REL9_5_20
  • REL9_6_16
  • REL_10_11
  • REL_11_6
  • REL_12_1
  • REL_12_0
  • REL_12_RC1
  • REL_12_BETA4
  • REL9_4_24
  • REL9_5_19
  • REL9_6_15
  • REL_10_10
  • REL_11_5
  • REL_12_BETA3
  • REL9_4_23
  • REL9_5_18
  • REL9_6_14
  • REL_10_9
  • REL_11_4
23 results

btree_float8.c

Blame
  • btree_float8.c 3.79 KiB
    #include "btree_gist.h"
    #include "btree_utils_num.h"
    
    typedef struct float8key
    {
    	float8		lower;
    	float8		upper;
    }	float8KEY;
    
    /*
    ** float8 ops
    */
    PG_FUNCTION_INFO_V1(gbt_float8_compress);
    PG_FUNCTION_INFO_V1(gbt_float8_union);
    PG_FUNCTION_INFO_V1(gbt_float8_picksplit);
    PG_FUNCTION_INFO_V1(gbt_float8_consistent);
    PG_FUNCTION_INFO_V1(gbt_float8_penalty);
    PG_FUNCTION_INFO_V1(gbt_float8_same);
    
    Datum		gbt_float8_compress(PG_FUNCTION_ARGS);
    Datum		gbt_float8_union(PG_FUNCTION_ARGS);
    Datum		gbt_float8_picksplit(PG_FUNCTION_ARGS);
    Datum		gbt_float8_consistent(PG_FUNCTION_ARGS);
    Datum		gbt_float8_penalty(PG_FUNCTION_ARGS);
    Datum		gbt_float8_same(PG_FUNCTION_ARGS);
    
    
    static bool
    gbt_float8gt(const void *a, const void *b)
    {
    	return (*((float8 *) a) > *((float8 *) b));
    }
    static bool
    gbt_float8ge(const void *a, const void *b)
    {
    	return (*((float8 *) a) >= *((float8 *) b));
    }
    static bool
    gbt_float8eq(const void *a, const void *b)
    {
    	return (*((float8 *) a) == *((float8 *) b));
    }
    static bool
    gbt_float8le(const void *a, const void *b)
    {
    	return (*((float8 *) a) <= *((float8 *) b));
    }
    static bool
    gbt_float8lt(const void *a, const void *b)
    {
    	return (*((float8 *) a) < *((float8 *) b));
    }
    
    static int
    gbt_float8key_cmp(const void *a, const void *b)
    {
    
    	if (*(float8 *) &(((Nsrt *) a)->t[0]) > *(float8 *) &(((Nsrt *) b)->t[0]))
    		return 1;
    	else if (*(float8 *) &(((Nsrt *) a)->t[0]) < *(float8 *) &(((Nsrt *) b)->t[0]))
    		return -1;
    	return 0;
    
    }
    
    
    static const gbtree_ninfo tinfo =
    {
    	gbt_t_float8,
    	sizeof(float8),
    	gbt_float8gt,
    	gbt_float8ge,
    	gbt_float8eq,
    	gbt_float8le,
    	gbt_float8lt,
    	gbt_float8key_cmp
    };
    
    
    /**************************************************
     * float8 ops
     **************************************************/
    
    
    Datum
    gbt_float8_compress(PG_FUNCTION_ARGS)
    {
    	GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
    	GISTENTRY  *retval = NULL;
    
    	PG_RETURN_POINTER(gbt_num_compress(retval, entry, &tinfo));
    }
    
    
    Datum
    gbt_float8_consistent(PG_FUNCTION_ARGS)
    {
    
    	GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
    	float8		query = PG_GETARG_FLOAT8(1);
    	float8KEY  *kkk = (float8KEY *) DatumGetPointer(entry->key);
    	GBT_NUMKEY_R key;
    	StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
    
    	key.lower = (GBT_NUMKEY *) & kkk->lower;
    	key.upper = (GBT_NUMKEY *) & kkk->upper;
    
    	PG_RETURN_BOOL(
    				   gbt_num_consistent(&key, (void *) &query, &strategy, GIST_LEAF(entry), &tinfo)
    		);
    }
    
    
    Datum
    gbt_float8_union(PG_FUNCTION_ARGS)
    {
    	GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
    	void	   *out = palloc(sizeof(float8KEY));
    
    	*(int *) PG_GETARG_POINTER(1) = sizeof(float8KEY);
    	PG_RETURN_POINTER(gbt_num_union((void *) out, entryvec, &tinfo));
    }
    
    
    Datum
    gbt_float8_penalty(PG_FUNCTION_ARGS)
    {
    	float8KEY  *origentry = (float8KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key);
    	float8KEY  *newentry = (float8KEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
    	float	   *result = (float *) PG_GETARG_POINTER(2);
    
    	float8		res;
    
    	*result = 0.0;
    
    	penalty_range_enlarge(origentry->lower, origentry->upper, newentry->lower, newentry->upper);
    
    	if (res > 0)
    	{
    		*result += FLT_MIN;
    		*result += (float) (res / ((double) (res + origentry->upper - origentry->lower)));
    		*result *= (FLT_MAX / (((GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1));
    	}
    
    	PG_RETURN_POINTER(result);
    
    }
    
    Datum
    gbt_float8_picksplit(PG_FUNCTION_ARGS)
    {
    	PG_RETURN_POINTER(gbt_num_picksplit(
    								(GistEntryVector *) PG_GETARG_POINTER(0),
    								  (GIST_SPLITVEC *) PG_GETARG_POINTER(1),
    										&tinfo
    										));
    }
    
    Datum
    gbt_float8_same(PG_FUNCTION_ARGS)
    {
    	float8KEY  *b1 = (float8KEY *) PG_GETARG_POINTER(0);
    	float8KEY  *b2 = (float8KEY *) PG_GETARG_POINTER(1);
    	bool	   *result = (bool *) PG_GETARG_POINTER(2);
    
    	*result = gbt_num_same((void *) b1, (void *) b2, &tinfo);
    	PG_RETURN_POINTER(result);
    }