385 lines
8.7 KiB
C
385 lines
8.7 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 *entry, const gbtree_ninfo *tinfo)
|
|
{
|
|
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(&r[0], leaf, tinfo->size);
|
|
memcpy(&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;
|
|
}
|
|
|
|
/*
|
|
* Convert a compressed leaf item back to the original type, for index-only
|
|
* scans.
|
|
*/
|
|
GISTENTRY *
|
|
gbt_num_fetch(GISTENTRY *entry, const gbtree_ninfo *tinfo)
|
|
{
|
|
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;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
** The GiST union method for numerical values
|
|
*/
|
|
|
|
void *
|
|
gbt_num_union(GBT_NUMKEY *out, const GistEntryVector *entryvec, const gbtree_ninfo *tinfo, FmgrInfo *flinfo)
|
|
{
|
|
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(out, 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;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
** The GiST same method for numerical values
|
|
*/
|
|
|
|
bool
|
|
gbt_num_same(const GBT_NUMKEY *a, const GBT_NUMKEY *b, const gbtree_ninfo *tinfo, FmgrInfo *flinfo)
|
|
{
|
|
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));
|
|
}
|
|
|
|
|
|
void
|
|
gbt_num_bin_union(Datum *u, GBT_NUMKEY *e, const gbtree_ninfo *tinfo, FmgrInfo *flinfo)
|
|
{
|
|
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);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* 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,
|
|
FmgrInfo *flinfo)
|
|
{
|
|
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;
|
|
}
|
|
|
|
|
|
/*
|
|
** 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,
|
|
FmgrInfo *flinfo)
|
|
{
|
|
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;
|
|
}
|
|
|
|
|
|
GIST_SPLITVEC *
|
|
gbt_num_picksplit(const GistEntryVector *entryvec, GIST_SPLITVEC *v,
|
|
const gbtree_ninfo *tinfo, FmgrInfo *flinfo)
|
|
{
|
|
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(&arr[FirstOffsetNumber], maxoff - FirstOffsetNumber + 1, sizeof(Nsrt), (qsort_arg_comparator) tinfo->f_cmp, 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;
|
|
}
|