mirror of
https://git.postgresql.org/git/postgresql.git
synced 2024-08-28 23:37:19 +02:00
The macaddr opclass stores two macaddr structs (each of size 6) in an index column that's declared as being of type gbtreekey16, ie 16 bytes. In the original coding this led to passing a palloc'd value of size 12 to the index insertion code, so that data would be fetched past the end of the allocated value during index tuple construction. This makes valgrind unhappy. In principle it could result in a SIGSEGV, though with the current implementation of palloc there's no risk since the 12-byte request size would be rounded up to 16 bytes anyway. To fix, add a field to struct gbtree_ninfo showing the declared size of the index datums, and use that in the palloc requests; and use palloc0 to be sure that any wasted bytes are cleanly initialized. Per report from Andres Freund. No back-patch since there's no current risk of a real problem.
315 lines
7.0 KiB
C
315 lines
7.0 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(tinfo->indexsize);
|
|
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);
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
** 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(palloc0(tinfo->indexsize));
|
|
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;
|
|
}
|