btree_utils_num.h File Reference

#include <math.h>
#include <float.h>
#include "access/gist.h"
#include "btree_gist.h"
#include "utils/rel.h"

Include dependency graph for btree_utils_num.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	GBT_NUMKEY_R
struct	Nsrt
struct	gbtree_ninfo

Macros
#define	penalty_num(result, olower, oupper, nlower, nupper)
#define	INTERVAL_TO_SEC(ivp)
#define	GET_FLOAT_DISTANCE(t, arg1, arg2)   fabs( ((float8) *((const t *) (arg1))) - ((float8) *((const t *) (arg2))) )

Typedefs
typedef char	GBT_NUMKEY

Functions
Interval *	abs_interval (Interval *a)
bool	gbt_num_consistent (const GBT_NUMKEY_R *key, const void *query, const StrategyNumber *strategy, bool is_leaf, const gbtree_ninfo *tinfo, FmgrInfo *flinfo)
float8	gbt_num_distance (const GBT_NUMKEY_R *key, const void *query, bool is_leaf, const gbtree_ninfo *tinfo, FmgrInfo *flinfo)
GIST_SPLITVEC *	gbt_num_picksplit (const GistEntryVector *entryvec, GIST_SPLITVEC *v, const gbtree_ninfo *tinfo, FmgrInfo *flinfo)
GISTENTRY *	gbt_num_compress (GISTENTRY *entry, const gbtree_ninfo *tinfo)
GISTENTRY *	gbt_num_fetch (GISTENTRY *entry, const gbtree_ninfo *tinfo)
void *	gbt_num_union (GBT_NUMKEY *out, const GistEntryVector *entryvec, const gbtree_ninfo *tinfo, FmgrInfo *flinfo)
bool	gbt_num_same (const GBT_NUMKEY *a, const GBT_NUMKEY *b, const gbtree_ninfo *tinfo, FmgrInfo *flinfo)
void	gbt_num_bin_union (Datum *u, GBT_NUMKEY *e, const gbtree_ninfo *tinfo, FmgrInfo *flinfo)

Macro Definition Documentation

GET_FLOAT_DISTANCE

#define GET_FLOAT_DISTANCE	(		t,
			arg1,
			arg2
	)		fabs( ((float8) *((const t *) (arg1))) - ((float8) *((const t *) (arg2))) )

Definition at line 90 of file btree_utils_num.h.

INTERVAL_TO_SEC

#define INTERVAL_TO_SEC

(

ivp

)

Value:

    (((double) (ivp)->time) / ((double) USECS_PER_SEC) + \
     (ivp)->day * (24.0 * SECS_PER_HOUR) + \
     (ivp)->month * (30.0 * SECS_PER_DAY))

Definition at line 85 of file btree_utils_num.h.

penalty_num

#define penalty_num	(		result,
			olower,
			oupper,
			nlower,
			nupper
	)

Value:

  do { \
  double    tmp = 0.0F; \
  (*(result))   = 0.0F; \
  if ( (nupper) > (oupper) ) \
      tmp += ( ((double)nupper)*0.49F - ((double)oupper)*0.49F ); \
  if (  (olower) > (nlower)  ) \
      tmp += ( ((double)olower)*0.49F - ((double)nlower)*0.49F ); \
  if (tmp > 0.0F) \
  { \
    (*(result)) += FLT_MIN; \
    (*(result)) += (float) ( ((double)(tmp)) / ( (double)(tmp) + ( ((double)(oupper))*0.49F - ((double)(olower))*0.49F ) ) ); \
    (*(result)) *= (FLT_MAX / (((GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1)); \
  } \
} while (0)

Definition at line 64 of file btree_utils_num.h.

Typedef Documentation

GBT_NUMKEY

typedef char GBT_NUMKEY

Definition at line 14 of file btree_utils_num.h.

Function Documentation

abs_interval()

Interval* abs_interval

(

Interval *

a

)

Definition at line 114 of file btree_interval.c.

{
    static Interval zero = {0, 0, 0};
 
    if (DatumGetBool(DirectFunctionCall2(interval_lt,
                                         IntervalPGetDatum(a),
                                         IntervalPGetDatum(&zero))))
        a = DatumGetIntervalP(DirectFunctionCall1(interval_um,
                                                  IntervalPGetDatum(a)));
 
    return a;
}

References a, DatumGetBool(), DatumGetIntervalP(), DirectFunctionCall1, DirectFunctionCall2, interval_lt(), interval_um(), and IntervalPGetDatum().

Referenced by interval_dist(), time_dist(), ts_dist(), and tstz_dist().

gbt_num_bin_union()

void gbt_num_bin_union	(	Datum *	u,
		GBT_NUMKEY *	e,
		const gbtree_ninfo *	tinfo,
		FmgrInfo *	flinfo
	)

Definition at line 228 of file btree_utils_num.c.

{
    GBT_NUMKEY_R rd;
 
    rd.lower = &e[0];
    rd.upper = &e[tinfo->size];
 
    if (!DatumGetPointer(*u))
    {
        *u = PointerGetDatum(palloc0(tinfo->indexsize));
        memcpy(&(((GBT_NUMKEY *) DatumGetPointer(*u))[0]), rd.lower, tinfo->size);
        memcpy(&(((GBT_NUMKEY *) DatumGetPointer(*u))[tinfo->size]), rd.upper, tinfo->size);
    }
    else
    {
        GBT_NUMKEY_R ur;
 
        ur.lower = &(((GBT_NUMKEY *) DatumGetPointer(*u))[0]);
        ur.upper = &(((GBT_NUMKEY *) DatumGetPointer(*u))[tinfo->size]);
        if (tinfo->f_gt(ur.lower, rd.lower, flinfo))
            memcpy(unconstify(GBT_NUMKEY *, ur.lower), rd.lower, tinfo->size);
        if (tinfo->f_lt(ur.upper, rd.upper, flinfo))
            memcpy(unconstify(GBT_NUMKEY *, ur.upper), rd.upper, tinfo->size);
    }
}

References DatumGetPointer(), gbtree_vinfo::f_gt, gbtree_vinfo::f_lt, GBT_NUMKEY_R::lower, palloc0(), PointerGetDatum(), tinfo, unconstify, and GBT_NUMKEY_R::upper.

Referenced by gbt_num_picksplit().

gbt_num_compress()

GISTENTRY* gbt_num_compress	(	GISTENTRY *	entry,
		const gbtree_ninfo *	tinfo
	)

Definition at line 14 of file btree_utils_num.c.

{
    GISTENTRY  *retval;
 
    if (entry->leafkey)
    {
        union
        {
            bool        bo;
            int16       i2;
            int32       i4;
            int64       i8;
            float4      f4;
            float8      f8;
            DateADT     dt;
            TimeADT     tm;
            Timestamp   ts;
            Cash        ch;
        }           v;
 
        GBT_NUMKEY *r = (GBT_NUMKEY *) palloc0(tinfo->indexsize);
        void       *leaf = NULL;
 
        switch (tinfo->t)
        {
            case gbt_t_bool:
                v.bo = DatumGetBool(entry->key);
                leaf = &v.bo;
                break;
            case gbt_t_int2:
                v.i2 = DatumGetInt16(entry->key);
                leaf = &v.i2;
                break;
            case gbt_t_int4:
                v.i4 = DatumGetInt32(entry->key);
                leaf = &v.i4;
                break;
            case gbt_t_int8:
                v.i8 = DatumGetInt64(entry->key);
                leaf = &v.i8;
                break;
            case gbt_t_oid:
            case gbt_t_enum:
                v.i4 = DatumGetObjectId(entry->key);
                leaf = &v.i4;
                break;
            case gbt_t_float4:
                v.f4 = DatumGetFloat4(entry->key);
                leaf = &v.f4;
                break;
            case gbt_t_float8:
                v.f8 = DatumGetFloat8(entry->key);
                leaf = &v.f8;
                break;
            case gbt_t_date:
                v.dt = DatumGetDateADT(entry->key);
                leaf = &v.dt;
                break;
            case gbt_t_time:
                v.tm = DatumGetTimeADT(entry->key);
                leaf = &v.tm;
                break;
            case gbt_t_ts:
                v.ts = DatumGetTimestamp(entry->key);
                leaf = &v.ts;
                break;
            case gbt_t_cash:
                v.ch = DatumGetCash(entry->key);
                leaf = &v.ch;
                break;
            default:
                leaf = DatumGetPointer(entry->key);
        }
 
        Assert(tinfo->indexsize >= 2 * tinfo->size);
 
        memcpy((void *) &r[0], leaf, tinfo->size);
        memcpy((void *) &r[tinfo->size], leaf, tinfo->size);
        retval = palloc(sizeof(GISTENTRY));
        gistentryinit(*retval, PointerGetDatum(r), entry->rel, entry->page,
                      entry->offset, false);
    }
    else
        retval = entry;
 
    return retval;
}

References Assert(), DatumGetBool(), DatumGetCash(), DatumGetDateADT(), DatumGetFloat4(), DatumGetFloat8(), DatumGetInt16(), DatumGetInt32(), DatumGetInt64(), DatumGetObjectId(), DatumGetPointer(), DatumGetTimeADT(), DatumGetTimestamp(), gbt_t_bool, gbt_t_cash, gbt_t_date, gbt_t_enum, gbt_t_float4, gbt_t_float8, gbt_t_int2, gbt_t_int4, gbt_t_int8, gbt_t_oid, gbt_t_time, gbt_t_ts, gistentryinit, GISTENTRY::key, GISTENTRY::leafkey, GISTENTRY::offset, GISTENTRY::page, palloc(), palloc0(), PointerGetDatum(), GISTENTRY::rel, gbtree_vinfo::t, tinfo, and tm.

Referenced by gbt_bool_compress(), gbt_cash_compress(), gbt_date_compress(), gbt_enum_compress(), gbt_float4_compress(), gbt_float8_compress(), gbt_int2_compress(), gbt_int4_compress(), gbt_int8_compress(), gbt_macad8_compress(), gbt_macad_compress(), gbt_oid_compress(), gbt_time_compress(), and gbt_ts_compress().

gbt_num_consistent()

bool gbt_num_consistent	(	const GBT_NUMKEY_R *	key,
		const void *	query,
		const StrategyNumber *	strategy,
		bool	is_leaf,
		const gbtree_ninfo *	tinfo,
		FmgrInfo *	flinfo
	)

Definition at line 263 of file btree_utils_num.c.

{
    bool        retval;
 
    switch (*strategy)
    {
        case BTLessEqualStrategyNumber:
            retval = tinfo->f_ge(query, key->lower, flinfo);
            break;
        case BTLessStrategyNumber:
            if (is_leaf)
                retval = tinfo->f_gt(query, key->lower, flinfo);
            else
                retval = tinfo->f_ge(query, key->lower, flinfo);
            break;
        case BTEqualStrategyNumber:
            if (is_leaf)
                retval = tinfo->f_eq(query, key->lower, flinfo);
            else
                retval = (tinfo->f_le(key->lower, query, flinfo) &&
                          tinfo->f_le(query, key->upper, flinfo));
            break;
        case BTGreaterStrategyNumber:
            if (is_leaf)
                retval = tinfo->f_lt(query, key->upper, flinfo);
            else
                retval = tinfo->f_le(query, key->upper, flinfo);
            break;
        case BTGreaterEqualStrategyNumber:
            retval = tinfo->f_le(query, key->upper, flinfo);
            break;
        case BtreeGistNotEqualStrategyNumber:
            retval = (!(tinfo->f_eq(query, key->lower, flinfo) &&
                        tinfo->f_eq(query, key->upper, flinfo)));
            break;
        default:
            retval = false;
    }
 
    return retval;
}

References BTEqualStrategyNumber, BTGreaterEqualStrategyNumber, BTGreaterStrategyNumber, BTLessEqualStrategyNumber, BTLessStrategyNumber, BtreeGistNotEqualStrategyNumber, gbtree_vinfo::f_eq, gbtree_vinfo::f_ge, gbtree_vinfo::f_gt, gbtree_vinfo::f_le, gbtree_vinfo::f_lt, sort-test::key, and tinfo.

Referenced by gbt_bool_consistent(), gbt_cash_consistent(), gbt_date_consistent(), gbt_enum_consistent(), gbt_float4_consistent(), gbt_float8_consistent(), gbt_inet_consistent(), gbt_int2_consistent(), gbt_int4_consistent(), gbt_int8_consistent(), gbt_intv_consistent(), gbt_macad8_consistent(), gbt_macad_consistent(), gbt_oid_consistent(), gbt_time_consistent(), gbt_timetz_consistent(), gbt_ts_consistent(), gbt_tstz_consistent(), and gbt_uuid_consistent().

gbt_num_distance()

float8 gbt_num_distance	(	const GBT_NUMKEY_R *	key,
		const void *	query,
		bool	is_leaf,
		const gbtree_ninfo *	tinfo,
		FmgrInfo *	flinfo
	)

Definition at line 316 of file btree_utils_num.c.

{
    float8      retval;
 
    if (tinfo->f_dist == NULL)
        elog(ERROR, "KNN search is not supported for btree_gist type %d",
             (int) tinfo->t);
    if (tinfo->f_le(query, key->lower, flinfo))
        retval = tinfo->f_dist(query, key->lower, flinfo);
    else if (tinfo->f_ge(query, key->upper, flinfo))
        retval = tinfo->f_dist(query, key->upper, flinfo);
    else
        retval = 0.0;
 
    return retval;
}

References elog(), ERROR, gbtree_vinfo::f_ge, gbtree_vinfo::f_le, sort-test::key, gbtree_vinfo::t, and tinfo.

Referenced by gbt_cash_distance(), gbt_date_distance(), gbt_float4_distance(), gbt_float8_distance(), gbt_int2_distance(), gbt_int4_distance(), gbt_int8_distance(), gbt_intv_distance(), gbt_oid_distance(), gbt_time_distance(), gbt_ts_distance(), and gbt_tstz_distance().

gbt_num_fetch()

GISTENTRY* gbt_num_fetch	(	GISTENTRY *	entry,
		const gbtree_ninfo *	tinfo
	)

Definition at line 107 of file btree_utils_num.c.

{
    GISTENTRY  *retval;
    Datum       datum;
 
    Assert(tinfo->indexsize >= 2 * tinfo->size);
 
    /*
     * Get the original Datum from the stored datum. On leaf entries, the
     * lower and upper bound are the same. We just grab the lower bound and
     * return it.
     */
    switch (tinfo->t)
    {
        case gbt_t_bool:
            datum = BoolGetDatum(*(bool *) entry->key);
            break;
        case gbt_t_int2:
            datum = Int16GetDatum(*(int16 *) entry->key);
            break;
        case gbt_t_int4:
            datum = Int32GetDatum(*(int32 *) entry->key);
            break;
        case gbt_t_int8:
            datum = Int64GetDatum(*(int64 *) entry->key);
            break;
        case gbt_t_oid:
        case gbt_t_enum:
            datum = ObjectIdGetDatum(*(Oid *) entry->key);
            break;
        case gbt_t_float4:
            datum = Float4GetDatum(*(float4 *) entry->key);
            break;
        case gbt_t_float8:
            datum = Float8GetDatum(*(float8 *) entry->key);
            break;
        case gbt_t_date:
            datum = DateADTGetDatum(*(DateADT *) entry->key);
            break;
        case gbt_t_time:
            datum = TimeADTGetDatum(*(TimeADT *) entry->key);
            break;
        case gbt_t_ts:
            datum = TimestampGetDatum(*(Timestamp *) entry->key);
            break;
        case gbt_t_cash:
            datum = CashGetDatum(*(Cash *) entry->key);
            break;
        default:
            datum = entry->key;
    }
 
    retval = palloc(sizeof(GISTENTRY));
    gistentryinit(*retval, datum, entry->rel, entry->page, entry->offset,
                  false);
    return retval;
}

References Assert(), BoolGetDatum(), CashGetDatum(), DateADTGetDatum(), Float4GetDatum(), Float8GetDatum(), gbt_t_bool, gbt_t_cash, gbt_t_date, gbt_t_enum, gbt_t_float4, gbt_t_float8, gbt_t_int2, gbt_t_int4, gbt_t_int8, gbt_t_oid, gbt_t_time, gbt_t_ts, gistentryinit, Int16GetDatum(), Int32GetDatum(), Int64GetDatum(), GISTENTRY::key, ObjectIdGetDatum(), GISTENTRY::offset, GISTENTRY::page, palloc(), GISTENTRY::rel, gbtree_vinfo::t, TimeADTGetDatum(), TimestampGetDatum(), and tinfo.

Referenced by gbt_bool_fetch(), gbt_cash_fetch(), gbt_date_fetch(), gbt_enum_fetch(), gbt_float4_fetch(), gbt_float8_fetch(), gbt_int2_fetch(), gbt_int4_fetch(), gbt_int8_fetch(), gbt_intv_fetch(), gbt_macad8_fetch(), gbt_macad_fetch(), gbt_oid_fetch(), gbt_time_fetch(), gbt_ts_fetch(), and gbt_uuid_fetch().

gbt_num_picksplit()

GIST_SPLITVEC* gbt_num_picksplit	(	const GistEntryVector *	entryvec,
		GIST_SPLITVEC *	v,
		const gbtree_ninfo *	tinfo,
		FmgrInfo *	flinfo
	)

Definition at line 339 of file btree_utils_num.c.

{
    OffsetNumber i,
                maxoff = entryvec->n - 1;
    Nsrt       *arr;
    int         nbytes;
 
    arr = (Nsrt *) palloc((maxoff + 1) * sizeof(Nsrt));
    nbytes = (maxoff + 2) * sizeof(OffsetNumber);
    v->spl_left = (OffsetNumber *) palloc(nbytes);
    v->spl_right = (OffsetNumber *) palloc(nbytes);
    v->spl_ldatum = PointerGetDatum(0);
    v->spl_rdatum = PointerGetDatum(0);
    v->spl_nleft = 0;
    v->spl_nright = 0;
 
    /* Sort entries */
 
    for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
    {
        arr[i].t = (GBT_NUMKEY *) DatumGetPointer((entryvec->vector[i].key));
        arr[i].i = i;
    }
    qsort_arg((void *) &arr[FirstOffsetNumber], maxoff - FirstOffsetNumber + 1, sizeof(Nsrt), (qsort_arg_comparator) tinfo->f_cmp, (void *) flinfo);
 
    /* We do simply create two parts */
 
    for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
    {
        if (i <= (maxoff - FirstOffsetNumber + 1) / 2)
        {
            gbt_num_bin_union(&v->spl_ldatum, arr[i].t, tinfo, flinfo);
            v->spl_left[v->spl_nleft] = arr[i].i;
            v->spl_nleft++;
        }
        else
        {
            gbt_num_bin_union(&v->spl_rdatum, arr[i].t, tinfo, flinfo);
            v->spl_right[v->spl_nright] = arr[i].i;
            v->spl_nright++;
        }
    }
 
    return v;
}

References DatumGetPointer(), gbtree_vinfo::f_cmp, FirstOffsetNumber, gbt_num_bin_union(), Nsrt::i, i, GISTENTRY::key, GistEntryVector::n, OffsetNumberNext, palloc(), PointerGetDatum(), qsort_arg(), GIST_SPLITVEC::spl_ldatum, GIST_SPLITVEC::spl_left, GIST_SPLITVEC::spl_nleft, GIST_SPLITVEC::spl_nright, GIST_SPLITVEC::spl_rdatum, GIST_SPLITVEC::spl_right, Nsrt::t, tinfo, and GistEntryVector::vector.

Referenced by gbt_bool_picksplit(), gbt_cash_picksplit(), gbt_date_picksplit(), gbt_enum_picksplit(), gbt_float4_picksplit(), gbt_float8_picksplit(), gbt_inet_picksplit(), gbt_int2_picksplit(), gbt_int4_picksplit(), gbt_int8_picksplit(), gbt_intv_picksplit(), gbt_macad8_picksplit(), gbt_macad_picksplit(), gbt_oid_picksplit(), gbt_time_picksplit(), gbt_ts_picksplit(), and gbt_uuid_picksplit().

gbt_num_same()

bool gbt_num_same	(	const GBT_NUMKEY *	a,
		const GBT_NUMKEY *	b,
		const gbtree_ninfo *	tinfo,
		FmgrInfo *	flinfo
	)

Definition at line 212 of file btree_utils_num.c.

{
    GBT_NUMKEY_R b1,
                b2;
 
    b1.lower = &(a[0]);
    b1.upper = &(a[tinfo->size]);
    b2.lower = &(b[0]);
    b2.upper = &(b[tinfo->size]);
 
    return (tinfo->f_eq(b1.lower, b2.lower, flinfo) &&
            tinfo->f_eq(b1.upper, b2.upper, flinfo));
}

References a, b, gbtree_vinfo::f_eq, GBT_NUMKEY_R::lower, tinfo, and GBT_NUMKEY_R::upper.

Referenced by gbt_bool_same(), gbt_cash_same(), gbt_date_same(), gbt_enum_same(), gbt_float4_same(), gbt_float8_same(), gbt_inet_same(), gbt_int2_same(), gbt_int4_same(), gbt_int8_same(), gbt_intv_same(), gbt_macad8_same(), gbt_macad_same(), gbt_oid_same(), gbt_time_same(), gbt_ts_same(), and gbt_uuid_same().

gbt_num_union()

void* gbt_num_union	(	GBT_NUMKEY *	out,
		const GistEntryVector *	entryvec,
		const gbtree_ninfo *	tinfo,
		FmgrInfo *	flinfo
	)

Definition at line 172 of file btree_utils_num.c.

{
    int         i,
                numranges;
    GBT_NUMKEY *cur;
    GBT_NUMKEY_R o,
                c;
 
    numranges = entryvec->n;
    cur = (GBT_NUMKEY *) DatumGetPointer((entryvec->vector[0].key));
 
 
    o.lower = &((GBT_NUMKEY *) out)[0];
    o.upper = &((GBT_NUMKEY *) out)[tinfo->size];
 
    memcpy((void *) out, (void *) cur, 2 * tinfo->size);
 
    for (i = 1; i < numranges; i++)
    {
        cur = (GBT_NUMKEY *) DatumGetPointer((entryvec->vector[i].key));
        c.lower = &cur[0];
        c.upper = &cur[tinfo->size];
        /* if out->lower > cur->lower, adopt cur as lower */
        if (tinfo->f_gt(o.lower, c.lower, flinfo))
            memcpy(unconstify(GBT_NUMKEY *, o.lower), c.lower, tinfo->size);
        /* if out->upper < cur->upper, adopt cur as upper */
        if (tinfo->f_lt(o.upper, c.upper, flinfo))
            memcpy(unconstify(GBT_NUMKEY *, o.upper), c.upper, tinfo->size);
    }
 
    return out;
}

References cur, DatumGetPointer(), gbtree_vinfo::f_gt, gbtree_vinfo::f_lt, i, GISTENTRY::key, GBT_NUMKEY_R::lower, GistEntryVector::n, tinfo, unconstify, GBT_NUMKEY_R::upper, and GistEntryVector::vector.

Referenced by gbt_bool_union(), gbt_cash_union(), gbt_date_union(), gbt_enum_union(), gbt_float4_union(), gbt_float8_union(), gbt_inet_union(), gbt_int2_union(), gbt_int4_union(), gbt_int8_union(), gbt_intv_union(), gbt_macad8_union(), gbt_macad_union(), gbt_oid_union(), gbt_time_union(), gbt_ts_union(), and gbt_uuid_union().