diff options
Diffstat (limited to 'contrib/seg/seg.c')
| -rw-r--r-- | contrib/seg/seg.c | 1094 |
1 files changed, 1094 insertions, 0 deletions
diff --git a/contrib/seg/seg.c b/contrib/seg/seg.c new file mode 100644 index 0000000..91b8a79 --- /dev/null +++ b/contrib/seg/seg.c @@ -0,0 +1,1094 @@ +/* + * contrib/seg/seg.c + * + ****************************************************************************** + This file contains routines that can be bound to a Postgres backend and + called by the backend in the process of processing queries. The calling + format for these routines is dictated by Postgres architecture. +******************************************************************************/ + +#include "postgres.h" + +#include <float.h> + +#include "access/gist.h" +#include "access/stratnum.h" +#include "fmgr.h" + +#include "segdata.h" + + +#define DatumGetSegP(X) ((SEG *) DatumGetPointer(X)) +#define PG_GETARG_SEG_P(n) DatumGetSegP(PG_GETARG_DATUM(n)) + + +/* +#define GIST_DEBUG +#define GIST_QUERY_DEBUG +*/ + +PG_MODULE_MAGIC; + +/* + * Auxiliary data structure for picksplit method. + */ +typedef struct +{ + float center; + OffsetNumber index; + SEG *data; +} gseg_picksplit_item; + +/* +** Input/Output routines +*/ +PG_FUNCTION_INFO_V1(seg_in); +PG_FUNCTION_INFO_V1(seg_out); +PG_FUNCTION_INFO_V1(seg_size); +PG_FUNCTION_INFO_V1(seg_lower); +PG_FUNCTION_INFO_V1(seg_upper); +PG_FUNCTION_INFO_V1(seg_center); + +/* +** GiST support methods +*/ +PG_FUNCTION_INFO_V1(gseg_consistent); +PG_FUNCTION_INFO_V1(gseg_compress); +PG_FUNCTION_INFO_V1(gseg_decompress); +PG_FUNCTION_INFO_V1(gseg_picksplit); +PG_FUNCTION_INFO_V1(gseg_penalty); +PG_FUNCTION_INFO_V1(gseg_union); +PG_FUNCTION_INFO_V1(gseg_same); +static Datum gseg_leaf_consistent(Datum key, Datum query, StrategyNumber strategy); +static Datum gseg_internal_consistent(Datum key, Datum query, StrategyNumber strategy); +static Datum gseg_binary_union(Datum r1, Datum r2, int *sizep); + + +/* +** R-tree support functions +*/ +PG_FUNCTION_INFO_V1(seg_same); +PG_FUNCTION_INFO_V1(seg_contains); +PG_FUNCTION_INFO_V1(seg_contained); +PG_FUNCTION_INFO_V1(seg_overlap); +PG_FUNCTION_INFO_V1(seg_left); +PG_FUNCTION_INFO_V1(seg_over_left); +PG_FUNCTION_INFO_V1(seg_right); +PG_FUNCTION_INFO_V1(seg_over_right); +PG_FUNCTION_INFO_V1(seg_union); +PG_FUNCTION_INFO_V1(seg_inter); +static void rt_seg_size(SEG *a, float *size); + +/* +** Various operators +*/ +PG_FUNCTION_INFO_V1(seg_cmp); +PG_FUNCTION_INFO_V1(seg_lt); +PG_FUNCTION_INFO_V1(seg_le); +PG_FUNCTION_INFO_V1(seg_gt); +PG_FUNCTION_INFO_V1(seg_ge); +PG_FUNCTION_INFO_V1(seg_different); + +/* +** Auxiliary functions +*/ +static int restore(char *s, float val, int n); + + +/***************************************************************************** + * Input/Output functions + *****************************************************************************/ + +Datum +seg_in(PG_FUNCTION_ARGS) +{ + char *str = PG_GETARG_CSTRING(0); + SEG *result = palloc(sizeof(SEG)); + + seg_scanner_init(str); + + if (seg_yyparse(result) != 0) + seg_yyerror(result, "bogus input"); + + seg_scanner_finish(); + + PG_RETURN_POINTER(result); +} + +Datum +seg_out(PG_FUNCTION_ARGS) +{ + SEG *seg = PG_GETARG_SEG_P(0); + char *result; + char *p; + + p = result = (char *) palloc(40); + + if (seg->l_ext == '>' || seg->l_ext == '<' || seg->l_ext == '~') + p += sprintf(p, "%c", seg->l_ext); + + if (seg->lower == seg->upper && seg->l_ext == seg->u_ext) + { + /* + * indicates that this interval was built by seg_in off a single point + */ + p += restore(p, seg->lower, seg->l_sigd); + } + else + { + if (seg->l_ext != '-') + { + /* print the lower boundary if exists */ + p += restore(p, seg->lower, seg->l_sigd); + p += sprintf(p, " "); + } + p += sprintf(p, ".."); + if (seg->u_ext != '-') + { + /* print the upper boundary if exists */ + p += sprintf(p, " "); + if (seg->u_ext == '>' || seg->u_ext == '<' || seg->l_ext == '~') + p += sprintf(p, "%c", seg->u_ext); + p += restore(p, seg->upper, seg->u_sigd); + } + } + + PG_RETURN_CSTRING(result); +} + +Datum +seg_center(PG_FUNCTION_ARGS) +{ + SEG *seg = PG_GETARG_SEG_P(0); + + PG_RETURN_FLOAT4(((float) seg->lower + (float) seg->upper) / 2.0); +} + +Datum +seg_lower(PG_FUNCTION_ARGS) +{ + SEG *seg = PG_GETARG_SEG_P(0); + + PG_RETURN_FLOAT4(seg->lower); +} + +Datum +seg_upper(PG_FUNCTION_ARGS) +{ + SEG *seg = PG_GETARG_SEG_P(0); + + PG_RETURN_FLOAT4(seg->upper); +} + + +/***************************************************************************** + * GiST functions + *****************************************************************************/ + +/* +** The GiST Consistent method for segments +** Should return false if for all data items x below entry, +** the predicate x op query == false, where op is the oper +** corresponding to strategy in the pg_amop table. +*/ +Datum +gseg_consistent(PG_FUNCTION_ARGS) +{ + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + Datum query = PG_GETARG_DATUM(1); + StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); + + /* Oid subtype = PG_GETARG_OID(3); */ + bool *recheck = (bool *) PG_GETARG_POINTER(4); + + /* All cases served by this function are exact */ + *recheck = false; + + /* + * if entry is not leaf, use gseg_internal_consistent, else use + * gseg_leaf_consistent + */ + if (GIST_LEAF(entry)) + return gseg_leaf_consistent(entry->key, query, strategy); + else + return gseg_internal_consistent(entry->key, query, strategy); +} + +/* +** The GiST Union method for segments +** returns the minimal bounding seg that encloses all the entries in entryvec +*/ +Datum +gseg_union(PG_FUNCTION_ARGS) +{ + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + int *sizep = (int *) PG_GETARG_POINTER(1); + int numranges, + i; + Datum out = 0; + Datum tmp; + +#ifdef GIST_DEBUG + fprintf(stderr, "union\n"); +#endif + + numranges = entryvec->n; + tmp = entryvec->vector[0].key; + *sizep = sizeof(SEG); + + for (i = 1; i < numranges; i++) + { + out = gseg_binary_union(tmp, entryvec->vector[i].key, sizep); + tmp = out; + } + + PG_RETURN_DATUM(out); +} + +/* +** GiST Compress and Decompress methods for segments +** do not do anything. +*/ +Datum +gseg_compress(PG_FUNCTION_ARGS) +{ + PG_RETURN_POINTER(PG_GETARG_POINTER(0)); +} + +Datum +gseg_decompress(PG_FUNCTION_ARGS) +{ + PG_RETURN_POINTER(PG_GETARG_POINTER(0)); +} + +/* +** The GiST Penalty method for segments +** As in the R-tree paper, we use change in area as our penalty metric +*/ +Datum +gseg_penalty(PG_FUNCTION_ARGS) +{ + GISTENTRY *origentry = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *newentry = (GISTENTRY *) PG_GETARG_POINTER(1); + float *result = (float *) PG_GETARG_POINTER(2); + SEG *ud; + float tmp1, + tmp2; + + ud = DatumGetSegP(DirectFunctionCall2(seg_union, + origentry->key, + newentry->key)); + rt_seg_size(ud, &tmp1); + rt_seg_size(DatumGetSegP(origentry->key), &tmp2); + *result = tmp1 - tmp2; + +#ifdef GIST_DEBUG + fprintf(stderr, "penalty\n"); + fprintf(stderr, "\t%g\n", *result); +#endif + + PG_RETURN_POINTER(result); +} + +/* + * Compare function for gseg_picksplit_item: sort by center. + */ +static int +gseg_picksplit_item_cmp(const void *a, const void *b) +{ + const gseg_picksplit_item *i1 = (const gseg_picksplit_item *) a; + const gseg_picksplit_item *i2 = (const gseg_picksplit_item *) b; + + if (i1->center < i2->center) + return -1; + else if (i1->center == i2->center) + return 0; + else + return 1; +} + +/* + * The GiST PickSplit method for segments + * + * We used to use Guttman's split algorithm here, but since the data is 1-D + * it's easier and more robust to just sort the segments by center-point and + * split at the middle. + */ +Datum +gseg_picksplit(PG_FUNCTION_ARGS) +{ + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1); + int i; + SEG *seg, + *seg_l, + *seg_r; + gseg_picksplit_item *sort_items; + OffsetNumber *left, + *right; + OffsetNumber maxoff; + OffsetNumber firstright; + +#ifdef GIST_DEBUG + fprintf(stderr, "picksplit\n"); +#endif + + /* Valid items in entryvec->vector[] are indexed 1..maxoff */ + maxoff = entryvec->n - 1; + + /* + * Prepare the auxiliary array and sort it. + */ + sort_items = (gseg_picksplit_item *) + palloc(maxoff * sizeof(gseg_picksplit_item)); + for (i = 1; i <= maxoff; i++) + { + seg = DatumGetSegP(entryvec->vector[i].key); + /* center calculation is done this way to avoid possible overflow */ + sort_items[i - 1].center = seg->lower * 0.5f + seg->upper * 0.5f; + sort_items[i - 1].index = i; + sort_items[i - 1].data = seg; + } + qsort(sort_items, maxoff, sizeof(gseg_picksplit_item), + gseg_picksplit_item_cmp); + + /* sort items below "firstright" will go into the left side */ + firstright = maxoff / 2; + + v->spl_left = (OffsetNumber *) palloc(maxoff * sizeof(OffsetNumber)); + v->spl_right = (OffsetNumber *) palloc(maxoff * sizeof(OffsetNumber)); + left = v->spl_left; + v->spl_nleft = 0; + right = v->spl_right; + v->spl_nright = 0; + + /* + * Emit segments to the left output page, and compute its bounding box. + */ + seg_l = (SEG *) palloc(sizeof(SEG)); + memcpy(seg_l, sort_items[0].data, sizeof(SEG)); + *left++ = sort_items[0].index; + v->spl_nleft++; + for (i = 1; i < firstright; i++) + { + Datum sortitem = PointerGetDatum(sort_items[i].data); + + seg_l = DatumGetSegP(DirectFunctionCall2(seg_union, + PointerGetDatum(seg_l), + sortitem)); + *left++ = sort_items[i].index; + v->spl_nleft++; + } + + /* + * Likewise for the right page. + */ + seg_r = (SEG *) palloc(sizeof(SEG)); + memcpy(seg_r, sort_items[firstright].data, sizeof(SEG)); + *right++ = sort_items[firstright].index; + v->spl_nright++; + for (i = firstright + 1; i < maxoff; i++) + { + Datum sortitem = PointerGetDatum(sort_items[i].data); + + seg_r = DatumGetSegP(DirectFunctionCall2(seg_union, + PointerGetDatum(seg_r), + sortitem)); + *right++ = sort_items[i].index; + v->spl_nright++; + } + + v->spl_ldatum = PointerGetDatum(seg_l); + v->spl_rdatum = PointerGetDatum(seg_r); + + PG_RETURN_POINTER(v); +} + +/* +** Equality methods +*/ +Datum +gseg_same(PG_FUNCTION_ARGS) +{ + bool *result = (bool *) PG_GETARG_POINTER(2); + + if (DirectFunctionCall2(seg_same, PG_GETARG_DATUM(0), PG_GETARG_DATUM(1))) + *result = true; + else + *result = false; + +#ifdef GIST_DEBUG + fprintf(stderr, "same: %s\n", (*result ? "TRUE" : "FALSE")); +#endif + + PG_RETURN_POINTER(result); +} + +/* +** SUPPORT ROUTINES +*/ +static Datum +gseg_leaf_consistent(Datum key, Datum query, StrategyNumber strategy) +{ + Datum retval; + +#ifdef GIST_QUERY_DEBUG + fprintf(stderr, "leaf_consistent, %d\n", strategy); +#endif + + switch (strategy) + { + case RTLeftStrategyNumber: + retval = DirectFunctionCall2(seg_left, key, query); + break; + case RTOverLeftStrategyNumber: + retval = DirectFunctionCall2(seg_over_left, key, query); + break; + case RTOverlapStrategyNumber: + retval = DirectFunctionCall2(seg_overlap, key, query); + break; + case RTOverRightStrategyNumber: + retval = DirectFunctionCall2(seg_over_right, key, query); + break; + case RTRightStrategyNumber: + retval = DirectFunctionCall2(seg_right, key, query); + break; + case RTSameStrategyNumber: + retval = DirectFunctionCall2(seg_same, key, query); + break; + case RTContainsStrategyNumber: + case RTOldContainsStrategyNumber: + retval = DirectFunctionCall2(seg_contains, key, query); + break; + case RTContainedByStrategyNumber: + case RTOldContainedByStrategyNumber: + retval = DirectFunctionCall2(seg_contained, key, query); + break; + default: + retval = false; + } + + PG_RETURN_DATUM(retval); +} + +static Datum +gseg_internal_consistent(Datum key, Datum query, StrategyNumber strategy) +{ + bool retval; + +#ifdef GIST_QUERY_DEBUG + fprintf(stderr, "internal_consistent, %d\n", strategy); +#endif + + switch (strategy) + { + case RTLeftStrategyNumber: + retval = + !DatumGetBool(DirectFunctionCall2(seg_over_right, key, query)); + break; + case RTOverLeftStrategyNumber: + retval = + !DatumGetBool(DirectFunctionCall2(seg_right, key, query)); + break; + case RTOverlapStrategyNumber: + retval = + DatumGetBool(DirectFunctionCall2(seg_overlap, key, query)); + break; + case RTOverRightStrategyNumber: + retval = + !DatumGetBool(DirectFunctionCall2(seg_left, key, query)); + break; + case RTRightStrategyNumber: + retval = + !DatumGetBool(DirectFunctionCall2(seg_over_left, key, query)); + break; + case RTSameStrategyNumber: + case RTContainsStrategyNumber: + case RTOldContainsStrategyNumber: + retval = + DatumGetBool(DirectFunctionCall2(seg_contains, key, query)); + break; + case RTContainedByStrategyNumber: + case RTOldContainedByStrategyNumber: + retval = + DatumGetBool(DirectFunctionCall2(seg_overlap, key, query)); + break; + default: + retval = false; + } + + PG_RETURN_BOOL(retval); +} + +static Datum +gseg_binary_union(Datum r1, Datum r2, int *sizep) +{ + Datum retval; + + retval = DirectFunctionCall2(seg_union, r1, r2); + *sizep = sizeof(SEG); + + return retval; +} + + +Datum +seg_contains(PG_FUNCTION_ARGS) +{ + SEG *a = PG_GETARG_SEG_P(0); + SEG *b = PG_GETARG_SEG_P(1); + + PG_RETURN_BOOL((a->lower <= b->lower) && (a->upper >= b->upper)); +} + +Datum +seg_contained(PG_FUNCTION_ARGS) +{ + Datum a = PG_GETARG_DATUM(0); + Datum b = PG_GETARG_DATUM(1); + + PG_RETURN_DATUM(DirectFunctionCall2(seg_contains, b, a)); +} + +/***************************************************************************** + * Operator class for R-tree indexing + *****************************************************************************/ + +Datum +seg_same(PG_FUNCTION_ARGS) +{ + int cmp = DatumGetInt32(DirectFunctionCall2(seg_cmp, + PG_GETARG_DATUM(0), + PG_GETARG_DATUM(1))); + + PG_RETURN_BOOL(cmp == 0); +} + +/* seg_overlap -- does a overlap b? + */ +Datum +seg_overlap(PG_FUNCTION_ARGS) +{ + SEG *a = PG_GETARG_SEG_P(0); + SEG *b = PG_GETARG_SEG_P(1); + + PG_RETURN_BOOL(((a->upper >= b->upper) && (a->lower <= b->upper)) || + ((b->upper >= a->upper) && (b->lower <= a->upper))); +} + +/* seg_over_left -- is the right edge of (a) located at or left of the right edge of (b)? + */ +Datum +seg_over_left(PG_FUNCTION_ARGS) +{ + SEG *a = PG_GETARG_SEG_P(0); + SEG *b = PG_GETARG_SEG_P(1); + + PG_RETURN_BOOL(a->upper <= b->upper); +} + +/* seg_left -- is (a) entirely on the left of (b)? + */ +Datum +seg_left(PG_FUNCTION_ARGS) +{ + SEG *a = PG_GETARG_SEG_P(0); + SEG *b = PG_GETARG_SEG_P(1); + + PG_RETURN_BOOL(a->upper < b->lower); +} + +/* seg_right -- is (a) entirely on the right of (b)? + */ +Datum +seg_right(PG_FUNCTION_ARGS) +{ + SEG *a = PG_GETARG_SEG_P(0); + SEG *b = PG_GETARG_SEG_P(1); + + PG_RETURN_BOOL(a->lower > b->upper); +} + +/* seg_over_right -- is the left edge of (a) located at or right of the left edge of (b)? + */ +Datum +seg_over_right(PG_FUNCTION_ARGS) +{ + SEG *a = PG_GETARG_SEG_P(0); + SEG *b = PG_GETARG_SEG_P(1); + + PG_RETURN_BOOL(a->lower >= b->lower); +} + +Datum +seg_union(PG_FUNCTION_ARGS) +{ + SEG *a = PG_GETARG_SEG_P(0); + SEG *b = PG_GETARG_SEG_P(1); + SEG *n; + + n = (SEG *) palloc(sizeof(*n)); + + /* take max of upper endpoints */ + if (a->upper > b->upper) + { + n->upper = a->upper; + n->u_sigd = a->u_sigd; + n->u_ext = a->u_ext; + } + else + { + n->upper = b->upper; + n->u_sigd = b->u_sigd; + n->u_ext = b->u_ext; + } + + /* take min of lower endpoints */ + if (a->lower < b->lower) + { + n->lower = a->lower; + n->l_sigd = a->l_sigd; + n->l_ext = a->l_ext; + } + else + { + n->lower = b->lower; + n->l_sigd = b->l_sigd; + n->l_ext = b->l_ext; + } + + PG_RETURN_POINTER(n); +} + +Datum +seg_inter(PG_FUNCTION_ARGS) +{ + SEG *a = PG_GETARG_SEG_P(0); + SEG *b = PG_GETARG_SEG_P(1); + SEG *n; + + n = (SEG *) palloc(sizeof(*n)); + + /* take min of upper endpoints */ + if (a->upper < b->upper) + { + n->upper = a->upper; + n->u_sigd = a->u_sigd; + n->u_ext = a->u_ext; + } + else + { + n->upper = b->upper; + n->u_sigd = b->u_sigd; + n->u_ext = b->u_ext; + } + + /* take max of lower endpoints */ + if (a->lower > b->lower) + { + n->lower = a->lower; + n->l_sigd = a->l_sigd; + n->l_ext = a->l_ext; + } + else + { + n->lower = b->lower; + n->l_sigd = b->l_sigd; + n->l_ext = b->l_ext; + } + + PG_RETURN_POINTER(n); +} + +static void +rt_seg_size(SEG *a, float *size) +{ + if (a == (SEG *) NULL || a->upper <= a->lower) + *size = 0.0; + else + *size = (float) Abs(a->upper - a->lower); +} + +Datum +seg_size(PG_FUNCTION_ARGS) +{ + SEG *seg = PG_GETARG_SEG_P(0); + + PG_RETURN_FLOAT4((float) Abs(seg->upper - seg->lower)); +} + + +/***************************************************************************** + * Miscellaneous operators + *****************************************************************************/ +Datum +seg_cmp(PG_FUNCTION_ARGS) +{ + SEG *a = PG_GETARG_SEG_P(0); + SEG *b = PG_GETARG_SEG_P(1); + + /* + * First compare on lower boundary position + */ + if (a->lower < b->lower) + PG_RETURN_INT32(-1); + if (a->lower > b->lower) + PG_RETURN_INT32(1); + + /* + * a->lower == b->lower, so consider type of boundary. + * + * A '-' lower bound is < any other kind (this could only be relevant if + * -HUGE_VAL is used as a regular data value). A '<' lower bound is < any + * other kind except '-'. A '>' lower bound is > any other kind. + */ + if (a->l_ext != b->l_ext) + { + if (a->l_ext == '-') + PG_RETURN_INT32(-1); + if (b->l_ext == '-') + PG_RETURN_INT32(1); + if (a->l_ext == '<') + PG_RETURN_INT32(-1); + if (b->l_ext == '<') + PG_RETURN_INT32(1); + if (a->l_ext == '>') + PG_RETURN_INT32(1); + if (b->l_ext == '>') + PG_RETURN_INT32(-1); + } + + /* + * For other boundary types, consider # of significant digits first. + */ + if (a->l_sigd < b->l_sigd) /* (a) is blurred and is likely to include (b) */ + PG_RETURN_INT32(-1); + if (a->l_sigd > b->l_sigd) /* (a) is less blurred and is likely to be + * included in (b) */ + PG_RETURN_INT32(1); + + /* + * For same # of digits, an approximate boundary is more blurred than + * exact. + */ + if (a->l_ext != b->l_ext) + { + if (a->l_ext == '~') /* (a) is approximate, while (b) is exact */ + PG_RETURN_INT32(-1); + if (b->l_ext == '~') + PG_RETURN_INT32(1); + /* can't get here unless data is corrupt */ + elog(ERROR, "bogus lower boundary types %d %d", + (int) a->l_ext, (int) b->l_ext); + } + + /* at this point, the lower boundaries are identical */ + + /* + * First compare on upper boundary position + */ + if (a->upper < b->upper) + PG_RETURN_INT32(-1); + if (a->upper > b->upper) + PG_RETURN_INT32(1); + + /* + * a->upper == b->upper, so consider type of boundary. + * + * A '-' upper bound is > any other kind (this could only be relevant if + * HUGE_VAL is used as a regular data value). A '<' upper bound is < any + * other kind. A '>' upper bound is > any other kind except '-'. + */ + if (a->u_ext != b->u_ext) + { + if (a->u_ext == '-') + PG_RETURN_INT32(1); + if (b->u_ext == '-') + PG_RETURN_INT32(-1); + if (a->u_ext == '<') + PG_RETURN_INT32(-1); + if (b->u_ext == '<') + PG_RETURN_INT32(1); + if (a->u_ext == '>') + PG_RETURN_INT32(1); + if (b->u_ext == '>') + PG_RETURN_INT32(-1); + } + + /* + * For other boundary types, consider # of significant digits first. Note + * result here is converse of the lower-boundary case. + */ + if (a->u_sigd < b->u_sigd) /* (a) is blurred and is likely to include (b) */ + PG_RETURN_INT32(1); + if (a->u_sigd > b->u_sigd) /* (a) is less blurred and is likely to be + * included in (b) */ + PG_RETURN_INT32(-1); + + /* + * For same # of digits, an approximate boundary is more blurred than + * exact. Again, result is converse of lower-boundary case. + */ + if (a->u_ext != b->u_ext) + { + if (a->u_ext == '~') /* (a) is approximate, while (b) is exact */ + PG_RETURN_INT32(1); + if (b->u_ext == '~') + PG_RETURN_INT32(-1); + /* can't get here unless data is corrupt */ + elog(ERROR, "bogus upper boundary types %d %d", + (int) a->u_ext, (int) b->u_ext); + } + + PG_RETURN_INT32(0); +} + +Datum +seg_lt(PG_FUNCTION_ARGS) +{ + int cmp = DatumGetInt32(DirectFunctionCall2(seg_cmp, + PG_GETARG_DATUM(0), + PG_GETARG_DATUM(1))); + + PG_RETURN_BOOL(cmp < 0); +} + +Datum +seg_le(PG_FUNCTION_ARGS) +{ + int cmp = DatumGetInt32(DirectFunctionCall2(seg_cmp, + PG_GETARG_DATUM(0), + PG_GETARG_DATUM(1))); + + PG_RETURN_BOOL(cmp <= 0); +} + +Datum +seg_gt(PG_FUNCTION_ARGS) +{ + int cmp = DatumGetInt32(DirectFunctionCall2(seg_cmp, + PG_GETARG_DATUM(0), + PG_GETARG_DATUM(1))); + + PG_RETURN_BOOL(cmp > 0); +} + +Datum +seg_ge(PG_FUNCTION_ARGS) +{ + int cmp = DatumGetInt32(DirectFunctionCall2(seg_cmp, + PG_GETARG_DATUM(0), + PG_GETARG_DATUM(1))); + + PG_RETURN_BOOL(cmp >= 0); +} + + +Datum +seg_different(PG_FUNCTION_ARGS) +{ + int cmp = DatumGetInt32(DirectFunctionCall2(seg_cmp, + PG_GETARG_DATUM(0), + PG_GETARG_DATUM(1))); + + PG_RETURN_BOOL(cmp != 0); +} + + + +/***************************************************************************** + * Auxiliary functions + *****************************************************************************/ + +/* + * The purpose of this routine is to print the given floating point + * value with exactly n significant digits. Its behaviour + * is similar to %.ng except it prints 8.00 where %.ng would + * print 8. Returns the length of the string written at "result". + * + * Caller must provide a sufficiently large result buffer; 16 bytes + * should be enough for all known float implementations. + */ +static int +restore(char *result, float val, int n) +{ + char buf[25] = { + '0', '0', '0', '0', '0', + '0', '0', '0', '0', '0', + '0', '0', '0', '0', '0', + '0', '0', '0', '0', '0', + '0', '0', '0', '0', '\0' + }; + char *p; + int exp; + int i, + dp, + sign; + + /* + * Put a cap on the number of significant digits to avoid garbage in the + * output and ensure we don't overrun the result buffer. (n should not be + * negative, but check to protect ourselves against corrupted data.) + */ + if (n <= 0) + n = FLT_DIG; + else + n = Min(n, FLT_DIG); + + /* remember the sign */ + sign = (val < 0 ? 1 : 0); + + /* print, in %e style to start with */ + sprintf(result, "%.*e", n - 1, val); + + /* find the exponent */ + p = strchr(result, 'e'); + + /* punt if we have 'inf' or similar */ + if (p == NULL) + return strlen(result); + + exp = atoi(p + 1); + if (exp == 0) + { + /* just truncate off the 'e+00' */ + *p = '\0'; + } + else + { + if (Abs(exp) <= 4) + { + /* + * remove the decimal point from the mantissa and write the digits + * to the buf array + */ + for (p = result + sign, i = 10, dp = 0; *p != 'e'; p++, i++) + { + buf[i] = *p; + if (*p == '.') + { + dp = i--; /* skip the decimal point */ + } + } + if (dp == 0) + dp = i--; /* no decimal point was found in the above + * for() loop */ + + if (exp > 0) + { + if (dp - 10 + exp >= n) + { + /* + * the decimal point is behind the last significant digit; + * the digits in between must be converted to the exponent + * and the decimal point placed after the first digit + */ + exp = dp - 10 + exp - n; + buf[10 + n] = '\0'; + + /* insert the decimal point */ + if (n > 1) + { + dp = 11; + for (i = 23; i > dp; i--) + buf[i] = buf[i - 1]; + buf[dp] = '.'; + } + + /* + * adjust the exponent by the number of digits after the + * decimal point + */ + if (n > 1) + sprintf(&buf[11 + n], "e%d", exp + n - 1); + else + sprintf(&buf[11], "e%d", exp + n - 1); + + if (sign) + { + buf[9] = '-'; + strcpy(result, &buf[9]); + } + else + strcpy(result, &buf[10]); + } + else + { /* insert the decimal point */ + dp += exp; + for (i = 23; i > dp; i--) + buf[i] = buf[i - 1]; + buf[11 + n] = '\0'; + buf[dp] = '.'; + if (sign) + { + buf[9] = '-'; + strcpy(result, &buf[9]); + } + else + strcpy(result, &buf[10]); + } + } + else + { /* exp <= 0 */ + dp += exp - 1; + buf[10 + n] = '\0'; + buf[dp] = '.'; + if (sign) + { + buf[dp - 2] = '-'; + strcpy(result, &buf[dp - 2]); + } + else + strcpy(result, &buf[dp - 1]); + } + } + + /* do nothing for Abs(exp) > 4; %e must be OK */ + /* just get rid of zeroes after [eE]- and +zeroes after [Ee]. */ + + /* ... this is not done yet. */ + } + return strlen(result); +} + + +/* +** Miscellany +*/ + +/* find out the number of significant digits in a string representing + * a floating point number + */ +int +significant_digits(const char *s) +{ + const char *p = s; + int n, + c, + zeroes; + + zeroes = 1; + /* skip leading zeroes and sign */ + for (c = *p; (c == '0' || c == '+' || c == '-') && c != 0; c = *(++p)); + + /* skip decimal point and following zeroes */ + for (c = *p; (c == '0' || c == '.') && c != 0; c = *(++p)) + { + if (c != '.') + zeroes++; + } + + /* count significant digits (n) */ + for (c = *p, n = 0; c != 0; c = *(++p)) + { + if (!((c >= '0' && c <= '9') || (c == '.'))) + break; + if (c != '.') + n++; + } + + if (!n) + return zeroes; + + return n; +} |