seg.c File Reference

#include "postgres.h"
#include <float.h>
#include <math.h>
#include "access/gist.h"
#include "access/stratnum.h"
#include "fmgr.h"
#include "segdata.h"

Include dependency graph for seg.c:

Go to the source code of this file.

Data Structures
struct	gseg_picksplit_item

Macros
#define	DatumGetSegP(X)   ((SEG *) DatumGetPointer(X))
#define	PG_GETARG_SEG_P(n)   DatumGetSegP(PG_GETARG_DATUM(n))

Functions
	PG_MODULE_MAGIC_EXT (.name="seg",.version=PG_VERSION)
	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)
	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)
	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)
	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)
static int	restore (char *result, float val, int n)
Datum	seg_in (PG_FUNCTION_ARGS)
Datum	seg_out (PG_FUNCTION_ARGS)
Datum	seg_center (PG_FUNCTION_ARGS)
Datum	seg_lower (PG_FUNCTION_ARGS)
Datum	seg_upper (PG_FUNCTION_ARGS)
Datum	gseg_consistent (PG_FUNCTION_ARGS)
Datum	gseg_union (PG_FUNCTION_ARGS)
Datum	gseg_compress (PG_FUNCTION_ARGS)
Datum	gseg_decompress (PG_FUNCTION_ARGS)
Datum	gseg_penalty (PG_FUNCTION_ARGS)
static int	gseg_picksplit_item_cmp (const void *a, const void *b)
Datum	gseg_picksplit (PG_FUNCTION_ARGS)
Datum	gseg_same (PG_FUNCTION_ARGS)
Datum	seg_contains (PG_FUNCTION_ARGS)
Datum	seg_contained (PG_FUNCTION_ARGS)
Datum	seg_same (PG_FUNCTION_ARGS)
Datum	seg_overlap (PG_FUNCTION_ARGS)
Datum	seg_over_left (PG_FUNCTION_ARGS)
Datum	seg_left (PG_FUNCTION_ARGS)
Datum	seg_right (PG_FUNCTION_ARGS)
Datum	seg_over_right (PG_FUNCTION_ARGS)
Datum	seg_union (PG_FUNCTION_ARGS)
Datum	seg_inter (PG_FUNCTION_ARGS)
Datum	seg_size (PG_FUNCTION_ARGS)
Datum	seg_cmp (PG_FUNCTION_ARGS)
Datum	seg_lt (PG_FUNCTION_ARGS)
Datum	seg_le (PG_FUNCTION_ARGS)
Datum	seg_gt (PG_FUNCTION_ARGS)
Datum	seg_ge (PG_FUNCTION_ARGS)
Datum	seg_different (PG_FUNCTION_ARGS)
int	significant_digits (const char *s)

Macro Definition Documentation

DatumGetSegP

#define DatumGetSegP

(

X

)

((SEG *) DatumGetPointer(X))

Definition at line 22 of file seg.c.

PG_GETARG_SEG_P

#define PG_GETARG_SEG_P

(

n

)

DatumGetSegP(PG_GETARG_DATUM(n))

Definition at line 23 of file seg.c.

Function Documentation

gseg_binary_union()

static Datum gseg_binary_union ( Datum  r1, Datum  r2, int *  sizep  )

static

Definition at line 529 of file seg.c.

{
    Datum       retval;
 
    retval = DirectFunctionCall2(seg_union, r1, r2);
    *sizep = sizeof(SEG);
 
    return retval;
}

References DirectFunctionCall2, and seg_union().

Referenced by gseg_union().

gseg_compress()

Datum gseg_compress

(

PG_FUNCTION_ARGS

)

Definition at line 258 of file seg.c.

{
    PG_RETURN_POINTER(PG_GETARG_POINTER(0));
}

References PG_GETARG_POINTER, and PG_RETURN_POINTER.

gseg_consistent()

Datum gseg_consistent

(

PG_FUNCTION_ARGS

)

Definition at line 200 of file seg.c.

{
    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);
}

References GIST_LEAF, gseg_internal_consistent(), gseg_leaf_consistent(), GISTENTRY::key, PG_GETARG_DATUM, PG_GETARG_POINTER, and PG_GETARG_UINT16.

gseg_decompress()

Datum gseg_decompress

(

PG_FUNCTION_ARGS

)

Definition at line 264 of file seg.c.

{
    PG_RETURN_POINTER(PG_GETARG_POINTER(0));
}

References PG_GETARG_POINTER, and PG_RETURN_POINTER.

gseg_internal_consistent()

static Datum gseg_internal_consistent ( Datum  key, Datum  query, StrategyNumber  strategy  )

static

Definition at line 480 of file seg.c.

{
    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);
}

References DatumGetBool(), DirectFunctionCall2, fprintf, sort-test::key, PG_RETURN_BOOL, RTContainedByStrategyNumber, RTContainsStrategyNumber, RTLeftStrategyNumber, RTOldContainedByStrategyNumber, RTOldContainsStrategyNumber, RTOverlapStrategyNumber, RTOverLeftStrategyNumber, RTOverRightStrategyNumber, RTRightStrategyNumber, RTSameStrategyNumber, seg_contains(), seg_left(), seg_over_left(), seg_over_right(), seg_overlap(), and seg_right().

Referenced by gseg_consistent().

gseg_leaf_consistent()

static Datum gseg_leaf_consistent ( Datum  key, Datum  query, StrategyNumber  strategy  )

static

Definition at line 436 of file seg.c.

{
    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);
}

References DirectFunctionCall2, fprintf, sort-test::key, PG_RETURN_DATUM, RTContainedByStrategyNumber, RTContainsStrategyNumber, RTLeftStrategyNumber, RTOldContainedByStrategyNumber, RTOldContainsStrategyNumber, RTOverlapStrategyNumber, RTOverLeftStrategyNumber, RTOverRightStrategyNumber, RTRightStrategyNumber, RTSameStrategyNumber, seg_contained(), seg_contains(), seg_left(), seg_over_left(), seg_over_right(), seg_overlap(), seg_right(), and seg_same().

Referenced by gseg_consistent().

gseg_penalty()

Datum gseg_penalty

(

PG_FUNCTION_ARGS

)

Definition at line 274 of file seg.c.

{
    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);
}

References DatumGetSegP, DirectFunctionCall2, fprintf, GISTENTRY::key, PG_GETARG_POINTER, PG_RETURN_POINTER, rt_seg_size(), and seg_union().

gseg_picksplit()

Datum gseg_picksplit

(

PG_FUNCTION_ARGS

)

Definition at line 323 of file seg.c.

{
    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);
}

References gseg_picksplit_item::center, gseg_picksplit_item::data, data, DatumGetSegP, DirectFunctionCall2, fprintf, gseg_picksplit_item_cmp(), i, gseg_picksplit_item::index, GISTENTRY::key, SEG::lower, GistEntryVector::n, palloc(), PG_GETARG_POINTER, PG_RETURN_POINTER, PointerGetDatum(), qsort, seg_union(), GIST_SPLITVEC::spl_ldatum, GIST_SPLITVEC::spl_left, GIST_SPLITVEC::spl_nleft, GIST_SPLITVEC::spl_nright, GIST_SPLITVEC::spl_rdatum, GIST_SPLITVEC::spl_right, SEG::upper, and GistEntryVector::vector.

gseg_picksplit_item_cmp()

static int gseg_picksplit_item_cmp ( const void *  a, const void *  b  )

static

Definition at line 302 of file seg.c.

{
    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;
}

References a, b, and gseg_picksplit_item::center.

Referenced by gseg_picksplit().

gseg_same()

Datum gseg_same

(

PG_FUNCTION_ARGS

)

Definition at line 416 of file seg.c.

{
    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);
}

References DirectFunctionCall2, fprintf, PG_GETARG_DATUM, PG_GETARG_POINTER, PG_RETURN_POINTER, and seg_same().

gseg_union()

Datum gseg_union

(

PG_FUNCTION_ARGS

)

Definition at line 227 of file seg.c.

{
    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);
}

References fprintf, gseg_binary_union(), i, GISTENTRY::key, GistEntryVector::n, PG_GETARG_POINTER, PG_RETURN_DATUM, and GistEntryVector::vector.

PG_FUNCTION_INFO_V1() [1/29]

PG_FUNCTION_INFO_V1

(

gseg_compress

)

PG_FUNCTION_INFO_V1() [2/29]

PG_FUNCTION_INFO_V1

(

gseg_consistent

)

PG_FUNCTION_INFO_V1() [3/29]

PG_FUNCTION_INFO_V1

(

gseg_decompress

)

PG_FUNCTION_INFO_V1() [4/29]

PG_FUNCTION_INFO_V1

(

gseg_penalty

)

PG_FUNCTION_INFO_V1() [5/29]

PG_FUNCTION_INFO_V1

(

gseg_picksplit

)

PG_FUNCTION_INFO_V1() [6/29]

PG_FUNCTION_INFO_V1

(

gseg_same

)

PG_FUNCTION_INFO_V1() [7/29]

PG_FUNCTION_INFO_V1

(

gseg_union

)

PG_FUNCTION_INFO_V1() [8/29]

PG_FUNCTION_INFO_V1

(

seg_center

)

PG_FUNCTION_INFO_V1() [9/29]

PG_FUNCTION_INFO_V1

(

seg_cmp

)

PG_FUNCTION_INFO_V1() [10/29]

PG_FUNCTION_INFO_V1

(

seg_contained

)

PG_FUNCTION_INFO_V1() [11/29]

PG_FUNCTION_INFO_V1

(

seg_contains

)

PG_FUNCTION_INFO_V1() [12/29]

PG_FUNCTION_INFO_V1

(

seg_different

)

PG_FUNCTION_INFO_V1() [13/29]

PG_FUNCTION_INFO_V1

(

seg_ge

)

PG_FUNCTION_INFO_V1() [14/29]

PG_FUNCTION_INFO_V1

(

seg_gt

)

PG_FUNCTION_INFO_V1() [15/29]

PG_FUNCTION_INFO_V1

(

seg_in

)

PG_FUNCTION_INFO_V1() [16/29]

PG_FUNCTION_INFO_V1

(

seg_inter

)

PG_FUNCTION_INFO_V1() [17/29]

PG_FUNCTION_INFO_V1

(

seg_le

)

PG_FUNCTION_INFO_V1() [18/29]

PG_FUNCTION_INFO_V1

(

seg_left

)

PG_FUNCTION_INFO_V1() [19/29]

PG_FUNCTION_INFO_V1

(

seg_lower

)

PG_FUNCTION_INFO_V1() [20/29]

PG_FUNCTION_INFO_V1

(

seg_lt

)

PG_FUNCTION_INFO_V1() [21/29]

PG_FUNCTION_INFO_V1

(

seg_out

)

PG_FUNCTION_INFO_V1() [22/29]

PG_FUNCTION_INFO_V1

(

seg_over_left

)

PG_FUNCTION_INFO_V1() [23/29]

PG_FUNCTION_INFO_V1

(

seg_over_right

)

PG_FUNCTION_INFO_V1() [24/29]

PG_FUNCTION_INFO_V1

(

seg_overlap

)

PG_FUNCTION_INFO_V1() [25/29]

PG_FUNCTION_INFO_V1

(

seg_right

)

PG_FUNCTION_INFO_V1() [26/29]

PG_FUNCTION_INFO_V1

(

seg_same

)

PG_FUNCTION_INFO_V1() [27/29]

PG_FUNCTION_INFO_V1

(

seg_size

)

PG_FUNCTION_INFO_V1() [28/29]

PG_FUNCTION_INFO_V1

(

seg_union

)

PG_FUNCTION_INFO_V1() [29/29]

PG_FUNCTION_INFO_V1

(

seg_upper

)

PG_MODULE_MAGIC_EXT()

PG_MODULE_MAGIC_EXT	(	.	name = "seg",
		.	version = PG_VERSION
	)

restore()

static int restore ( char *  result, float  val, int  n  )

static

Definition at line 918 of file seg.c.

{
    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);
}

References buf, i, Min, sign, sprintf, and val.

Referenced by seg_out().

rt_seg_size()

static void rt_seg_size ( SEG *  a, float *  size  )

static

Definition at line 709 of file seg.c.

{
    if (a == (SEG *) NULL || a->upper <= a->lower)
        *size = 0.0;
    else
        *size = fabsf(a->upper - a->lower);
}

References a.

Referenced by gseg_penalty().

seg_center()

Datum seg_center

(

PG_FUNCTION_ARGS

)

Definition at line 165 of file seg.c.

{
    SEG        *seg = PG_GETARG_SEG_P(0);
 
    PG_RETURN_FLOAT4(((float) seg->lower + (float) seg->upper) / 2.0);
}

References SEG::lower, PG_GETARG_SEG_P, PG_RETURN_FLOAT4, and SEG::upper.

seg_cmp()

Datum seg_cmp

(

PG_FUNCTION_ARGS

)

Definition at line 730 of file seg.c.

{
    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);
}

References a, b, elog, ERROR, PG_GETARG_SEG_P, and PG_RETURN_INT32.

Referenced by seg_different(), seg_ge(), seg_gt(), seg_le(), seg_lt(), and seg_same().

seg_contained()

Datum seg_contained

(

PG_FUNCTION_ARGS

)

Definition at line 550 of file seg.c.

{
    Datum       a = PG_GETARG_DATUM(0);
    Datum       b = PG_GETARG_DATUM(1);
 
    PG_RETURN_DATUM(DirectFunctionCall2(seg_contains, b, a));
}

References a, b, DirectFunctionCall2, PG_GETARG_DATUM, PG_RETURN_DATUM, and seg_contains().

Referenced by gseg_leaf_consistent().

seg_contains()

Datum seg_contains

(

PG_FUNCTION_ARGS

)

Definition at line 541 of file seg.c.

{
    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));
}

References a, b, PG_GETARG_SEG_P, and PG_RETURN_BOOL.

Referenced by gseg_internal_consistent(), gseg_leaf_consistent(), and seg_contained().

seg_different()

Datum seg_different

(

PG_FUNCTION_ARGS

)

Definition at line 893 of file seg.c.

{
    int         cmp = DatumGetInt32(DirectFunctionCall2(seg_cmp,
                                                        PG_GETARG_DATUM(0),
                                                        PG_GETARG_DATUM(1)));
 
    PG_RETURN_BOOL(cmp != 0);
}

References cmp(), DatumGetInt32(), DirectFunctionCall2, PG_GETARG_DATUM, PG_RETURN_BOOL, and seg_cmp().

seg_ge()

Datum seg_ge

(

PG_FUNCTION_ARGS

)

Definition at line 882 of file seg.c.

{
    int         cmp = DatumGetInt32(DirectFunctionCall2(seg_cmp,
                                                        PG_GETARG_DATUM(0),
                                                        PG_GETARG_DATUM(1)));
 
    PG_RETURN_BOOL(cmp >= 0);
}

References cmp(), DatumGetInt32(), DirectFunctionCall2, PG_GETARG_DATUM, PG_RETURN_BOOL, and seg_cmp().

seg_gt()

Datum seg_gt

(

PG_FUNCTION_ARGS

)

Definition at line 872 of file seg.c.

{
    int         cmp = DatumGetInt32(DirectFunctionCall2(seg_cmp,
                                                        PG_GETARG_DATUM(0),
                                                        PG_GETARG_DATUM(1)));
 
    PG_RETURN_BOOL(cmp > 0);
}

References cmp(), DatumGetInt32(), DirectFunctionCall2, PG_GETARG_DATUM, PG_RETURN_BOOL, and seg_cmp().

seg_in()

Datum seg_in

(

PG_FUNCTION_ARGS

)

Definition at line 107 of file seg.c.

{
    char       *str = PG_GETARG_CSTRING(0);
    SEG        *result = palloc(sizeof(SEG));
    yyscan_t    scanner;
 
    seg_scanner_init(str, &scanner);
 
    if (seg_yyparse(result, fcinfo->context, scanner) != 0)
        seg_yyerror(result, fcinfo->context, scanner, "bogus input");
 
    seg_scanner_finish(scanner);
 
    PG_RETURN_POINTER(result);
}

References palloc(), PG_GETARG_CSTRING, PG_RETURN_POINTER, seg_scanner_finish(), seg_scanner_init(), seg_yyerror(), seg_yyparse(), and str.

seg_inter()

Datum seg_inter

(

PG_FUNCTION_ARGS

)

Definition at line 669 of file seg.c.

{
    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);
}

References a, b, SEG::l_ext, SEG::l_sigd, SEG::lower, palloc(), PG_GETARG_SEG_P, PG_RETURN_POINTER, SEG::u_ext, SEG::u_sigd, and SEG::upper.

seg_le()

Datum seg_le

(

PG_FUNCTION_ARGS

)

Definition at line 862 of file seg.c.

{
    int         cmp = DatumGetInt32(DirectFunctionCall2(seg_cmp,
                                                        PG_GETARG_DATUM(0),
                                                        PG_GETARG_DATUM(1)));
 
    PG_RETURN_BOOL(cmp <= 0);
}

References cmp(), DatumGetInt32(), DirectFunctionCall2, PG_GETARG_DATUM, PG_RETURN_BOOL, and seg_cmp().

seg_left()

Datum seg_left

(

PG_FUNCTION_ARGS

)

Definition at line 598 of file seg.c.

{
    SEG        *a = PG_GETARG_SEG_P(0);
    SEG        *b = PG_GETARG_SEG_P(1);
 
    PG_RETURN_BOOL(a->upper < b->lower);
}

References a, b, PG_GETARG_SEG_P, and PG_RETURN_BOOL.

Referenced by gseg_internal_consistent(), and gseg_leaf_consistent().

seg_lower()

Datum seg_lower

(

PG_FUNCTION_ARGS

)

Definition at line 173 of file seg.c.

{
    SEG        *seg = PG_GETARG_SEG_P(0);
 
    PG_RETURN_FLOAT4(seg->lower);
}

References SEG::lower, PG_GETARG_SEG_P, and PG_RETURN_FLOAT4.

seg_lt()

Datum seg_lt

(

PG_FUNCTION_ARGS

)

Definition at line 852 of file seg.c.

{
    int         cmp = DatumGetInt32(DirectFunctionCall2(seg_cmp,
                                                        PG_GETARG_DATUM(0),
                                                        PG_GETARG_DATUM(1)));
 
    PG_RETURN_BOOL(cmp < 0);
}

References cmp(), DatumGetInt32(), DirectFunctionCall2, PG_GETARG_DATUM, PG_RETURN_BOOL, and seg_cmp().

seg_out()

Datum seg_out

(

PG_FUNCTION_ARGS

)

Definition at line 124 of file seg.c.

{
    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);
}

References SEG::l_ext, SEG::l_sigd, SEG::lower, palloc(), PG_GETARG_SEG_P, PG_RETURN_CSTRING, restore(), sprintf, SEG::u_ext, SEG::u_sigd, and SEG::upper.

seg_over_left()

Datum seg_over_left

(

PG_FUNCTION_ARGS

)

Definition at line 587 of file seg.c.

{
    SEG        *a = PG_GETARG_SEG_P(0);
    SEG        *b = PG_GETARG_SEG_P(1);
 
    PG_RETURN_BOOL(a->upper <= b->upper);
}

References a, b, PG_GETARG_SEG_P, and PG_RETURN_BOOL.

Referenced by gseg_internal_consistent(), and gseg_leaf_consistent().

seg_over_right()

Datum seg_over_right

(

PG_FUNCTION_ARGS

)

Definition at line 620 of file seg.c.

{
    SEG        *a = PG_GETARG_SEG_P(0);
    SEG        *b = PG_GETARG_SEG_P(1);
 
    PG_RETURN_BOOL(a->lower >= b->lower);
}

References a, b, PG_GETARG_SEG_P, and PG_RETURN_BOOL.

Referenced by gseg_internal_consistent(), and gseg_leaf_consistent().

seg_overlap()

Datum seg_overlap

(

PG_FUNCTION_ARGS

)

Definition at line 575 of file seg.c.

{
    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)));
}

References a, b, PG_GETARG_SEG_P, and PG_RETURN_BOOL.

Referenced by gseg_internal_consistent(), and gseg_leaf_consistent().

seg_right()

Datum seg_right

(

PG_FUNCTION_ARGS

)

Definition at line 609 of file seg.c.

{
    SEG        *a = PG_GETARG_SEG_P(0);
    SEG        *b = PG_GETARG_SEG_P(1);
 
    PG_RETURN_BOOL(a->lower > b->upper);
}

References a, b, PG_GETARG_SEG_P, and PG_RETURN_BOOL.

Referenced by gseg_internal_consistent(), and gseg_leaf_consistent().

seg_same()

Datum seg_same

(

PG_FUNCTION_ARGS

)

Definition at line 563 of file seg.c.

{
    int         cmp = DatumGetInt32(DirectFunctionCall2(seg_cmp,
                                                        PG_GETARG_DATUM(0),
                                                        PG_GETARG_DATUM(1)));
 
    PG_RETURN_BOOL(cmp == 0);
}

References cmp(), DatumGetInt32(), DirectFunctionCall2, PG_GETARG_DATUM, PG_RETURN_BOOL, and seg_cmp().

Referenced by gseg_leaf_consistent(), and gseg_same().

seg_size()

Datum seg_size

(

PG_FUNCTION_ARGS

)

Definition at line 718 of file seg.c.

{
    SEG        *seg = PG_GETARG_SEG_P(0);
 
    PG_RETURN_FLOAT4(fabsf(seg->upper - seg->lower));
}

References SEG::lower, PG_GETARG_SEG_P, PG_RETURN_FLOAT4, and SEG::upper.

seg_union()

Datum seg_union

(

PG_FUNCTION_ARGS

)

Definition at line 629 of file seg.c.

{
    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);
}

References a, b, SEG::l_ext, SEG::l_sigd, SEG::lower, palloc(), PG_GETARG_SEG_P, PG_RETURN_POINTER, SEG::u_ext, SEG::u_sigd, and SEG::upper.

Referenced by gseg_binary_union(), gseg_penalty(), and gseg_picksplit().

seg_upper()

Datum seg_upper

(

PG_FUNCTION_ARGS

)

Definition at line 181 of file seg.c.

{
    SEG        *seg = PG_GETARG_SEG_P(0);
 
    PG_RETURN_FLOAT4(seg->upper);
}

References PG_GETARG_SEG_P, PG_RETURN_FLOAT4, and SEG::upper.

significant_digits()

int significant_digits

(

const char *

s

)

Definition at line 1068 of file seg.c.

{
    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;
}