postgresql/contrib/btree_gist/btree_utils_num.c
Tom Lane a7801b62f2 Move Timestamp/Interval typedefs and basic macros into datatype/timestamp.h.
As per my recent proposal, this refactors things so that these typedefs and
macros are available in a header that can be included in frontend-ish code.
I also changed various headers that were undesirably including
utils/timestamp.h to include datatype/timestamp.h instead.  Unsurprisingly,
this showed that half the system was getting utils/timestamp.h by way of
xlog.h.

No actual code changes here, just header refactoring.
2011-09-09 13:23:41 -04:00

315 lines
6.9 KiB
C

/*
* contrib/btree_gist/btree_utils_num.c
*/
#include "postgres.h"
#include "btree_gist.h"
#include "btree_utils_num.h"
#include "utils/cash.h"
#include "utils/date.h"
#include "utils/timestamp.h"
GISTENTRY *
gbt_num_compress(GISTENTRY *retval, GISTENTRY *entry, const gbtree_ninfo *tinfo)
{
if (entry->leafkey)
{
union
{
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(2 * tinfo->size);
void *leaf = NULL;
switch (tinfo->t)
{
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:
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);
}
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;
}
/*
** The GiST union method for numerical values
*/
void *
gbt_num_union(GBT_NUMKEY *out, const GistEntryVector *entryvec, const gbtree_ninfo *tinfo)
{
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 ((*tinfo->f_gt) (o.lower, c.lower)) /* out->lower > cur->lower */
memcpy((void *) o.lower, (void *) c.lower, tinfo->size);
if ((*tinfo->f_lt) (o.upper, c.upper)) /* out->upper < cur->upper */
memcpy((void *) o.upper, (void *) c.upper, tinfo->size);
}
return out;
}
/*
** The GiST same method for numerical values
*/
bool
gbt_num_same(const GBT_NUMKEY *a, const GBT_NUMKEY *b, const gbtree_ninfo *tinfo)
{
GBT_NUMKEY_R b1,
b2;
b1.lower = &(((GBT_NUMKEY *) a)[0]);
b1.upper = &(((GBT_NUMKEY *) a)[tinfo->size]);
b2.lower = &(((GBT_NUMKEY *) b)[0]);
b2.upper = &(((GBT_NUMKEY *) b)[tinfo->size]);
if (
(*tinfo->f_eq) (b1.lower, b2.lower) &&
(*tinfo->f_eq) (b1.upper, b2.upper)
)
return TRUE;
return FALSE;
}
void
gbt_num_bin_union(Datum *u, GBT_NUMKEY *e, const gbtree_ninfo *tinfo)
{
GBT_NUMKEY_R rd;
rd.lower = &e[0];
rd.upper = &e[tinfo->size];
if (!DatumGetPointer(*u))
{
*u = PointerGetDatum(palloc(2 * tinfo->size));
memcpy((void *) &(((GBT_NUMKEY *) DatumGetPointer(*u))[0]), (void *) rd.lower, tinfo->size);
memcpy((void *) &(((GBT_NUMKEY *) DatumGetPointer(*u))[tinfo->size]), (void *) 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) ((void *) ur.lower, (void *) rd.lower))
memcpy((void *) ur.lower, (void *) rd.lower, tinfo->size);
if ((*tinfo->f_lt) ((void *) ur.upper, (void *) rd.upper))
memcpy((void *) ur.upper, (void *) rd.upper, tinfo->size);
}
}
/*
* The GiST consistent method
*
* Note: we currently assume that no datatypes that use this routine are
* collation-aware; so we don't bother passing collation through.
*/
bool
gbt_num_consistent(const GBT_NUMKEY_R *key,
const void *query,
const StrategyNumber *strategy,
bool is_leaf,
const gbtree_ninfo *tinfo)
{
bool retval;
switch (*strategy)
{
case BTLessEqualStrategyNumber:
retval = (*tinfo->f_ge) (query, key->lower);
break;
case BTLessStrategyNumber:
if (is_leaf)
retval = (*tinfo->f_gt) (query, key->lower);
else
retval = (*tinfo->f_ge) (query, key->lower);
break;
case BTEqualStrategyNumber:
if (is_leaf)
retval = (*tinfo->f_eq) (query, key->lower);
else
retval = ((*tinfo->f_le) (key->lower, query) && (*tinfo->f_le) (query, key->upper)) ? true : false;
break;
case BTGreaterStrategyNumber:
if (is_leaf)
retval = (*tinfo->f_lt) (query, key->upper);
else
retval = (*tinfo->f_le) (query, key->upper);
break;
case BTGreaterEqualStrategyNumber:
retval = (*tinfo->f_le) (query, key->upper);
break;
case BtreeGistNotEqualStrategyNumber:
retval = (!((*tinfo->f_eq) (query, key->lower) &&
(*tinfo->f_eq) (query, key->upper))) ? true : false;
break;
default:
retval = false;
}
return (retval);
}
/*
** The GiST distance method (for KNN-Gist)
*/
float8
gbt_num_distance(const GBT_NUMKEY_R *key,
const void *query,
bool is_leaf,
const gbtree_ninfo *tinfo)
{
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))
retval = tinfo->f_dist(query, key->lower);
else if (tinfo->f_ge(query, key->upper))
retval = tinfo->f_dist(query, key->upper);
else
retval = 0.0;
return retval;
}
GIST_SPLITVEC *
gbt_num_picksplit(const GistEntryVector *entryvec, GIST_SPLITVEC *v,
const gbtree_ninfo *tinfo)
{
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((void *) &arr[FirstOffsetNumber], maxoff - FirstOffsetNumber + 1, sizeof(Nsrt), tinfo->f_cmp);
/* 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);
v->spl_left[v->spl_nleft] = arr[i].i;
v->spl_nleft++;
}
else
{
gbt_num_bin_union(&v->spl_rdatum, arr[i].t, tinfo);
v->spl_right[v->spl_nright] = arr[i].i;
v->spl_nright++;
}
}
return v;
}