#include "postgres.h"
#include "access/spgist.h"
#include "access/spgist_private.h"
#include "access/stratnum.h"
#include "catalog/pg_type.h"
#include "utils/float.h"
#include "utils/fmgroids.h"
#include "utils/fmgrprotos.h"
#include "utils/geo_decls.h"

Include dependency graph for geo_spgist.c:

Data Structures
struct	Range

struct	RangeBox

struct	RectBox

Functions
static int	compareDoubles (const void a, const void b)

static uint8	getQuadrant (BOX centroid, BOX inBox)

static RangeBox *	getRangeBox (BOX *box)

static RectBox *	initRectBox (void)

static RectBox *	nextRectBox (RectBox rect_box, RangeBox centroid, uint8 quadrant)

static bool	overlap2D (RangeBox range_box, Range query)

static bool	overlap4D (RectBox rect_box, RangeBox query)

static bool	contain2D (RangeBox range_box, Range query)

static bool	contain4D (RectBox rect_box, RangeBox query)

static bool	contained2D (RangeBox range_box, Range query)

static bool	contained4D (RectBox rect_box, RangeBox query)

static bool	lower2D (RangeBox range_box, Range query)

static bool	overLower2D (RangeBox range_box, Range query)

static bool	higher2D (RangeBox range_box, Range query)

static bool	overHigher2D (RangeBox range_box, Range query)

static bool	left4D (RectBox rect_box, RangeBox query)

static bool	overLeft4D (RectBox rect_box, RangeBox query)

static bool	right4D (RectBox rect_box, RangeBox query)

static bool	overRight4D (RectBox rect_box, RangeBox query)

static bool	below4D (RectBox rect_box, RangeBox query)

static bool	overBelow4D (RectBox rect_box, RangeBox query)

static bool	above4D (RectBox rect_box, RangeBox query)

static bool	overAbove4D (RectBox rect_box, RangeBox query)

static double	pointToRectBoxDistance (Point point, RectBox rect_box)

Datum	spg_box_quad_config (PG_FUNCTION_ARGS)

Datum	spg_box_quad_choose (PG_FUNCTION_ARGS)

Datum	spg_box_quad_picksplit (PG_FUNCTION_ARGS)

static bool	is_bounding_box_test_exact (StrategyNumber strategy)

static BOX *	spg_box_quad_get_scankey_bbox (ScanKey sk, bool *recheck)

Datum	spg_box_quad_inner_consistent (PG_FUNCTION_ARGS)

Datum	spg_box_quad_leaf_consistent (PG_FUNCTION_ARGS)

Datum	spg_bbox_quad_config (PG_FUNCTION_ARGS)

Datum	spg_poly_quad_compress (PG_FUNCTION_ARGS)

Function Documentation

◆ above4D()

static bool above4D	(	RectBox *	rect_box,
		RangeBox *	query
	)

static

Definition at line 360 of file geo_spgist.c.

 {
     return higher2D(&rect_box->range_box_y, &query->right);
 }

References higher2D(), RectBox::range_box_y, and RangeBox::right.

Referenced by spg_box_quad_inner_consistent().

◆ below4D()

static bool below4D	(	RectBox *	rect_box,
		RangeBox *	query
	)

static

Definition at line 346 of file geo_spgist.c.

 {
     return lower2D(&rect_box->range_box_y, &query->right);
 }

References lower2D(), RectBox::range_box_y, and RangeBox::right.

Referenced by spg_box_quad_inner_consistent().

◆ compareDoubles()

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

static

Definition at line 93 of file geo_spgist.c.

 {
     float8      x = *(float8 *) a;
     float8      y = *(float8 *) b;
  
     if (x == y)
         return 0;
     return (x > y) ? 1 : -1;
 }

References a, b, x, and y.

Referenced by spg_box_quad_picksplit().

◆ contain2D()

static bool contain2D	(	RangeBox *	range_box,
		Range *	query
	)

static

Definition at line 252 of file geo_spgist.c.

 {
     return FPge(range_box->right.high, query->high) &&
         FPle(range_box->left.low, query->low);
 }

References FPge(), FPle(), Range::high, RangeBox::left, Range::low, and RangeBox::right.

Referenced by contain4D().

◆ contain4D()

static bool contain4D	(	RectBox *	rect_box,
		RangeBox *	query
	)

static

Definition at line 260 of file geo_spgist.c.

 {
     return contain2D(&rect_box->range_box_x, &query->left) &&
         contain2D(&rect_box->range_box_y, &query->right);
 }

References contain2D(), RangeBox::left, RectBox::range_box_x, RectBox::range_box_y, and RangeBox::right.

Referenced by spg_box_quad_inner_consistent().

◆ contained2D()

static bool contained2D	(	RangeBox *	range_box,
		Range *	query
	)

static

Definition at line 268 of file geo_spgist.c.

 {
     return FPle(range_box->left.low, query->high) &&
         FPge(range_box->left.high, query->low) &&
         FPle(range_box->right.low, query->high) &&
         FPge(range_box->right.high, query->low);
 }

References FPge(), FPle(), Range::high, RangeBox::left, Range::low, and RangeBox::right.

Referenced by contained4D().

◆ contained4D()

static bool contained4D	(	RectBox *	rect_box,
		RangeBox *	query
	)

static

Definition at line 278 of file geo_spgist.c.

 {
     return contained2D(&rect_box->range_box_x, &query->left) &&
         contained2D(&rect_box->range_box_y, &query->right);
 }

References contained2D(), RangeBox::left, RectBox::range_box_x, RectBox::range_box_y, and RangeBox::right.

Referenced by spg_box_quad_inner_consistent().

◆ getQuadrant()

static uint8 getQuadrant	(	BOX *	centroid,
		BOX *	inBox
	)

static

Definition at line 130 of file geo_spgist.c.

 {
     uint8       quadrant = 0;
  
     if (inBox->low.x > centroid->low.x)
         quadrant |= 0x8;
  
     if (inBox->high.x > centroid->high.x)
         quadrant |= 0x4;
  
     if (inBox->low.y > centroid->low.y)
         quadrant |= 0x2;
  
     if (inBox->high.y > centroid->high.y)
         quadrant |= 0x1;
  
     return quadrant;
 }

References BOX::high, BOX::low, Point::x, and Point::y.

Referenced by spg_box_quad_choose(), and spg_box_quad_picksplit().

◆ getRangeBox()

static RangeBox* getRangeBox ( BOX * box )

static

Definition at line 157 of file geo_spgist.c.

 {
     RangeBox   *range_box = (RangeBox *) palloc(sizeof(RangeBox));
  
     range_box->left.low = box->low.x;
     range_box->left.high = box->high.x;
  
     range_box->right.low = box->low.y;
     range_box->right.high = box->high.y;
  
     return range_box;
 }

References Range::high, BOX::high, RangeBox::left, Range::low, BOX::low, palloc(), RangeBox::right, Point::x, and Point::y.

Referenced by spg_box_quad_inner_consistent().

◆ higher2D()

static bool higher2D	(	RangeBox *	range_box,
		Range *	query
	)

static

Definition at line 302 of file geo_spgist.c.

 {
     return FPgt(range_box->left.high, query->high) &&
         FPgt(range_box->right.high, query->high);
 }

References FPgt(), Range::high, RangeBox::left, and RangeBox::right.

Referenced by above4D(), and right4D().

◆ initRectBox()

static RectBox* initRectBox ( void )

static

Definition at line 177 of file geo_spgist.c.

 {
     RectBox    *rect_box = (RectBox *) palloc(sizeof(RectBox));
     float8      infinity = get_float8_infinity();
  
     rect_box->range_box_x.left.low = -infinity;
     rect_box->range_box_x.left.high = infinity;
  
     rect_box->range_box_x.right.low = -infinity;
     rect_box->range_box_x.right.high = infinity;
  
     rect_box->range_box_y.left.low = -infinity;
     rect_box->range_box_y.left.high = infinity;
  
     rect_box->range_box_y.right.low = -infinity;
     rect_box->range_box_y.right.high = infinity;
  
     return rect_box;
 }

References get_float8_infinity(), Range::high, RangeBox::left, Range::low, palloc(), RectBox::range_box_x, RectBox::range_box_y, and RangeBox::right.

Referenced by spg_box_quad_inner_consistent().

◆ is_bounding_box_test_exact()

static bool is_bounding_box_test_exact ( StrategyNumber strategy )

static

Definition at line 508 of file geo_spgist.c.

 {
     switch (strategy)
     {
         case RTLeftStrategyNumber:
         case RTOverLeftStrategyNumber:
         case RTOverRightStrategyNumber:
         case RTRightStrategyNumber:
         case RTOverBelowStrategyNumber:
         case RTBelowStrategyNumber:
         case RTAboveStrategyNumber:
         case RTOverAboveStrategyNumber:
             return true;
  
         default:
             return false;
     }
 }

References RTAboveStrategyNumber, RTBelowStrategyNumber, RTLeftStrategyNumber, RTOverAboveStrategyNumber, RTOverBelowStrategyNumber, RTOverLeftStrategyNumber, RTOverRightStrategyNumber, and RTRightStrategyNumber.

Referenced by spg_box_quad_get_scankey_bbox().

◆ left4D()

static bool left4D	(	RectBox *	rect_box,
		RangeBox *	query
	)

static

Definition at line 318 of file geo_spgist.c.

 {
     return lower2D(&rect_box->range_box_x, &query->left);
 }

References RangeBox::left, lower2D(), and RectBox::range_box_x.

Referenced by spg_box_quad_inner_consistent().

◆ lower2D()

static bool lower2D	(	RangeBox *	range_box,
		Range *	query
	)

static

Definition at line 286 of file geo_spgist.c.

 {
     return FPlt(range_box->left.low, query->low) &&
         FPlt(range_box->right.low, query->low);
 }

References FPlt(), RangeBox::left, Range::low, and RangeBox::right.

Referenced by below4D(), and left4D().

◆ nextRectBox()

static RectBox* nextRectBox	(	RectBox *	rect_box,
		RangeBox *	centroid,
		uint8	quadrant
	)

static

Definition at line 205 of file geo_spgist.c.

 {
     RectBox    *next_rect_box = (RectBox *) palloc(sizeof(RectBox));
  
     memcpy(next_rect_box, rect_box, sizeof(RectBox));
  
     if (quadrant & 0x8)
         next_rect_box->range_box_x.left.low = centroid->left.low;
     else
         next_rect_box->range_box_x.left.high = centroid->left.low;
  
     if (quadrant & 0x4)
         next_rect_box->range_box_x.right.low = centroid->left.high;
     else
         next_rect_box->range_box_x.right.high = centroid->left.high;
  
     if (quadrant & 0x2)
         next_rect_box->range_box_y.left.low = centroid->right.low;
     else
         next_rect_box->range_box_y.left.high = centroid->right.low;
  
     if (quadrant & 0x1)
         next_rect_box->range_box_y.right.low = centroid->right.high;
     else
         next_rect_box->range_box_y.right.high = centroid->right.high;
  
     return next_rect_box;
 }

References Range::high, RangeBox::left, Range::low, palloc(), RectBox::range_box_x, RectBox::range_box_y, and RangeBox::right.

Referenced by spg_box_quad_inner_consistent().

◆ overAbove4D()

static bool overAbove4D	(	RectBox *	rect_box,
		RangeBox *	query
	)

static

Definition at line 367 of file geo_spgist.c.

 {
     return overHigher2D(&rect_box->range_box_y, &query->right);
 }

References overHigher2D(), RectBox::range_box_y, and RangeBox::right.

Referenced by spg_box_quad_inner_consistent().

◆ overBelow4D()

static bool overBelow4D	(	RectBox *	rect_box,
		RangeBox *	query
	)

static

Definition at line 353 of file geo_spgist.c.

 {
     return overLower2D(&rect_box->range_box_y, &query->right);
 }

References overLower2D(), RectBox::range_box_y, and RangeBox::right.

Referenced by spg_box_quad_inner_consistent().

◆ overHigher2D()

static bool overHigher2D	(	RangeBox *	range_box,
		Range *	query
	)

static

Definition at line 310 of file geo_spgist.c.

 {
     return FPge(range_box->left.high, query->low) &&
         FPge(range_box->right.high, query->low);
 }

References FPge(), Range::high, RangeBox::left, Range::low, and RangeBox::right.

Referenced by overAbove4D(), and overRight4D().

◆ overlap2D()

static bool overlap2D	(	RangeBox *	range_box,
		Range *	query
	)

static

Definition at line 236 of file geo_spgist.c.

 {
     return FPge(range_box->right.high, query->low) &&
         FPle(range_box->left.low, query->high);
 }

References FPge(), FPle(), Range::high, RangeBox::left, Range::low, and RangeBox::right.

Referenced by overlap4D().

◆ overlap4D()

static bool overlap4D	(	RectBox *	rect_box,
		RangeBox *	query
	)

static

Definition at line 244 of file geo_spgist.c.

 {
     return overlap2D(&rect_box->range_box_x, &query->left) &&
         overlap2D(&rect_box->range_box_y, &query->right);
 }

References RangeBox::left, overlap2D(), RectBox::range_box_x, RectBox::range_box_y, and RangeBox::right.

Referenced by spg_box_quad_inner_consistent().

◆ overLeft4D()

static bool overLeft4D	(	RectBox *	rect_box,
		RangeBox *	query
	)

static

Definition at line 325 of file geo_spgist.c.

 {
     return overLower2D(&rect_box->range_box_x, &query->left);
 }

References RangeBox::left, overLower2D(), and RectBox::range_box_x.

Referenced by spg_box_quad_inner_consistent().

◆ overLower2D()

static bool overLower2D	(	RangeBox *	range_box,
		Range *	query
	)

static

Definition at line 294 of file geo_spgist.c.

 {
     return FPle(range_box->left.low, query->high) &&
         FPle(range_box->right.low, query->high);
 }

References FPle(), Range::high, RangeBox::left, Range::low, and RangeBox::right.

Referenced by overBelow4D(), and overLeft4D().

◆ overRight4D()

static bool overRight4D	(	RectBox *	rect_box,
		RangeBox *	query
	)

static

Definition at line 339 of file geo_spgist.c.

 {
     return overHigher2D(&rect_box->range_box_x, &query->left);
 }

References RangeBox::left, overHigher2D(), and RectBox::range_box_x.

Referenced by spg_box_quad_inner_consistent().

◆ pointToRectBoxDistance()

static double pointToRectBoxDistance	(	Point *	point,
		RectBox *	rect_box
	)

static

Definition at line 374 of file geo_spgist.c.

 {
     double      dx;
     double      dy;
  
     if (point->x < rect_box->range_box_x.left.low)
         dx = rect_box->range_box_x.left.low - point->x;
     else if (point->x > rect_box->range_box_x.right.high)
         dx = point->x - rect_box->range_box_x.right.high;
     else
         dx = 0;
  
     if (point->y < rect_box->range_box_y.left.low)
         dy = rect_box->range_box_y.left.low - point->y;
     else if (point->y > rect_box->range_box_y.right.high)
         dy = point->y - rect_box->range_box_y.right.high;
     else
         dy = 0;
  
     return HYPOT(dx, dy);
 }

References Range::high, HYPOT, RangeBox::left, Range::low, RectBox::range_box_x, RectBox::range_box_y, RangeBox::right, Point::x, and Point::y.

Referenced by spg_box_quad_inner_consistent().

◆ right4D()

static bool right4D	(	RectBox *	rect_box,
		RangeBox *	query
	)

static

Definition at line 332 of file geo_spgist.c.

 {
     return higher2D(&rect_box->range_box_x, &query->left);
 }

References higher2D(), RangeBox::left, and RectBox::range_box_x.

Referenced by spg_box_quad_inner_consistent().

◆ spg_bbox_quad_config()

Datum spg_bbox_quad_config ( PG_FUNCTION_ARGS )

Definition at line 859 of file geo_spgist.c.

 {
     spgConfigOut *cfg = (spgConfigOut *) PG_GETARG_POINTER(1);
  
     cfg->prefixType = BOXOID;   /* A type represented by its bounding box */
     cfg->labelType = VOIDOID;   /* We don't need node labels. */
     cfg->leafType = BOXOID;
     cfg->canReturnData = false;
     cfg->longValuesOK = false;
  
     PG_RETURN_VOID();
 }

References spgConfigOut::canReturnData, spgConfigOut::labelType, spgConfigOut::leafType, spgConfigOut::longValuesOK, PG_GETARG_POINTER, PG_RETURN_VOID, and spgConfigOut::prefixType.

◆ spg_box_quad_choose()

Datum spg_box_quad_choose ( PG_FUNCTION_ARGS )

Definition at line 417 of file geo_spgist.c.

 {
     spgChooseIn *in = (spgChooseIn *) PG_GETARG_POINTER(0);
     spgChooseOut *out = (spgChooseOut *) PG_GETARG_POINTER(1);
     BOX        *centroid = DatumGetBoxP(in->prefixDatum),
                *box = DatumGetBoxP(in->leafDatum);
  
     out->resultType = spgMatchNode;
     out->result.matchNode.restDatum = BoxPGetDatum(box);
  
     /* nodeN will be set by core, when allTheSame. */
     if (!in->allTheSame)
         out->result.matchNode.nodeN = getQuadrant(centroid, box);
  
     PG_RETURN_VOID();
 }

References spgChooseIn::allTheSame, BoxPGetDatum(), DatumGetBoxP(), getQuadrant(), spgChooseIn::leafDatum, spgChooseOut::matchNode, PG_GETARG_POINTER, PG_RETURN_VOID, spgChooseIn::prefixDatum, spgChooseOut::result, spgChooseOut::resultType, and spgMatchNode.

◆ spg_box_quad_config()

Datum spg_box_quad_config ( PG_FUNCTION_ARGS )

Definition at line 401 of file geo_spgist.c.

 {
     spgConfigOut *cfg = (spgConfigOut *) PG_GETARG_POINTER(1);
  
     cfg->prefixType = BOXOID;
     cfg->labelType = VOIDOID;   /* We don't need node labels. */
     cfg->canReturnData = true;
     cfg->longValuesOK = false;
  
     PG_RETURN_VOID();
 }

References spgConfigOut::canReturnData, spgConfigOut::labelType, spgConfigOut::longValuesOK, PG_GETARG_POINTER, PG_RETURN_VOID, and spgConfigOut::prefixType.

◆ spg_box_quad_get_scankey_bbox()

static BOX* spg_box_quad_get_scankey_bbox	(	ScanKey	sk,
		bool *	recheck
	)

static

Definition at line 531 of file geo_spgist.c.

 {
     switch (sk->sk_subtype)
     {
         case BOXOID:
             return DatumGetBoxP(sk->sk_argument);
  
         case POLYGONOID:
             if (recheck && !is_bounding_box_test_exact(sk->sk_strategy))
                 *recheck = true;
             return &DatumGetPolygonP(sk->sk_argument)->boundbox;
  
         default:
             elog(ERROR, "unrecognized scankey subtype: %d", sk->sk_subtype);
             return NULL;
     }
 }

References POLYGON::boundbox, DatumGetBoxP(), DatumGetPolygonP(), elog, ERROR, is_bounding_box_test_exact(), ScanKeyData::sk_argument, ScanKeyData::sk_strategy, and ScanKeyData::sk_subtype.

Referenced by spg_box_quad_inner_consistent(), and spg_box_quad_leaf_consistent().

◆ spg_box_quad_inner_consistent()

Datum spg_box_quad_inner_consistent ( PG_FUNCTION_ARGS )

Definition at line 553 of file geo_spgist.c.

 {
     spgInnerConsistentIn *in = (spgInnerConsistentIn *) PG_GETARG_POINTER(0);
     spgInnerConsistentOut *out = (spgInnerConsistentOut *) PG_GETARG_POINTER(1);
     int         i;
     MemoryContext old_ctx;
     RectBox    *rect_box;
     uint8       quadrant;
     RangeBox   *centroid,
               **queries;
  
     /*
      * We are saving the traversal value or initialize it an unbounded one, if
      * we have just begun to walk the tree.
      */
     if (in->traversalValue)
         rect_box = in->traversalValue;
     else
         rect_box = initRectBox();
  
     if (in->allTheSame)
     {
         /* Report that all nodes should be visited */
         out->nNodes = in->nNodes;
         out->nodeNumbers = (int *) palloc(sizeof(int) * in->nNodes);
         for (i = 0; i < in->nNodes; i++)
             out->nodeNumbers[i] = i;
  
         if (in->norderbys > 0 && in->nNodes > 0)
         {
             double     *distances = palloc(sizeof(double) * in->norderbys);
             int         j;
  
             for (j = 0; j < in->norderbys; j++)
             {
                 Point      *pt = DatumGetPointP(in->orderbys[j].sk_argument);
  
                 distances[j] = pointToRectBoxDistance(pt, rect_box);
             }
  
             out->distances = (double **) palloc(sizeof(double *) * in->nNodes);
             out->distances[0] = distances;
  
             for (i = 1; i < in->nNodes; i++)
             {
                 out->distances[i] = palloc(sizeof(double) * in->norderbys);
                 memcpy(out->distances[i], distances,
                        sizeof(double) * in->norderbys);
             }
         }
  
         PG_RETURN_VOID();
     }
  
     /*
      * We are casting the prefix and queries to RangeBoxes for ease of the
      * following operations.
      */
     centroid = getRangeBox(DatumGetBoxP(in->prefixDatum));
     queries = (RangeBox **) palloc(in->nkeys * sizeof(RangeBox *));
     for (i = 0; i < in->nkeys; i++)
     {
         BOX        *box = spg_box_quad_get_scankey_bbox(&in->scankeys[i], NULL);
  
         queries[i] = getRangeBox(box);
     }
  
     /* Allocate enough memory for nodes */
     out->nNodes = 0;
     out->nodeNumbers = (int *) palloc(sizeof(int) * in->nNodes);
     out->traversalValues = (void **) palloc(sizeof(void *) * in->nNodes);
     if (in->norderbys > 0)
         out->distances = (double **) palloc(sizeof(double *) * in->nNodes);
  
     /*
      * We switch memory context, because we want to allocate memory for new
      * traversal values (next_rect_box) and pass these pieces of memory to
      * further call of this function.
      */
     old_ctx = MemoryContextSwitchTo(in->traversalMemoryContext);
  
     for (quadrant = 0; quadrant < in->nNodes; quadrant++)
     {
         RectBox    *next_rect_box = nextRectBox(rect_box, centroid, quadrant);
         bool        flag = true;
  
         for (i = 0; i < in->nkeys; i++)
         {
             StrategyNumber strategy = in->scankeys[i].sk_strategy;
  
             switch (strategy)
             {
                 case RTOverlapStrategyNumber:
                     flag = overlap4D(next_rect_box, queries[i]);
                     break;
  
                 case RTContainsStrategyNumber:
                     flag = contain4D(next_rect_box, queries[i]);
                     break;
  
                 case RTSameStrategyNumber:
                 case RTContainedByStrategyNumber:
                     flag = contained4D(next_rect_box, queries[i]);
                     break;
  
                 case RTLeftStrategyNumber:
                     flag = left4D(next_rect_box, queries[i]);
                     break;
  
                 case RTOverLeftStrategyNumber:
                     flag = overLeft4D(next_rect_box, queries[i]);
                     break;
  
                 case RTRightStrategyNumber:
                     flag = right4D(next_rect_box, queries[i]);
                     break;
  
                 case RTOverRightStrategyNumber:
                     flag = overRight4D(next_rect_box, queries[i]);
                     break;
  
                 case RTAboveStrategyNumber:
                     flag = above4D(next_rect_box, queries[i]);
                     break;
  
                 case RTOverAboveStrategyNumber:
                     flag = overAbove4D(next_rect_box, queries[i]);
                     break;
  
                 case RTBelowStrategyNumber:
                     flag = below4D(next_rect_box, queries[i]);
                     break;
  
                 case RTOverBelowStrategyNumber:
                     flag = overBelow4D(next_rect_box, queries[i]);
                     break;
  
                 default:
                     elog(ERROR, "unrecognized strategy: %d", strategy);
             }
  
             /* If any check is failed, we have found our answer. */
             if (!flag)
                 break;
         }
  
         if (flag)
         {
             out->traversalValues[out->nNodes] = next_rect_box;
             out->nodeNumbers[out->nNodes] = quadrant;
  
             if (in->norderbys > 0)
             {
                 double     *distances = palloc(sizeof(double) * in->norderbys);
                 int         j;
  
                 out->distances[out->nNodes] = distances;
  
                 for (j = 0; j < in->norderbys; j++)
                 {
                     Point      *pt = DatumGetPointP(in->orderbys[j].sk_argument);
  
                     distances[j] = pointToRectBoxDistance(pt, next_rect_box);
                 }
             }
  
             out->nNodes++;
         }
         else
         {
             /*
              * If this node is not selected, we don't need to keep the next
              * traversal value in the memory context.
              */
             pfree(next_rect_box);
         }
     }
  
     /* Switch back */
     MemoryContextSwitchTo(old_ctx);
  
     PG_RETURN_VOID();
 }

◆ spg_box_quad_leaf_consistent()

Datum spg_box_quad_leaf_consistent ( PG_FUNCTION_ARGS )

Definition at line 741 of file geo_spgist.c.

 {
     spgLeafConsistentIn *in = (spgLeafConsistentIn *) PG_GETARG_POINTER(0);
     spgLeafConsistentOut *out = (spgLeafConsistentOut *) PG_GETARG_POINTER(1);
     Datum       leaf = in->leafDatum;
     bool        flag = true;
     int         i;
  
     /* All tests are exact. */
     out->recheck = false;
  
     /*
      * Don't return leafValue unless told to; this is used for both box and
      * polygon opclasses, and in the latter case the leaf datum is not even of
      * the right type to return.
      */
     if (in->returnData)
         out->leafValue = leaf;
  
     /* Perform the required comparison(s) */
     for (i = 0; i < in->nkeys; i++)
     {
         StrategyNumber strategy = in->scankeys[i].sk_strategy;
         BOX        *box = spg_box_quad_get_scankey_bbox(&in->scankeys[i],
                                                         &out->recheck);
         Datum       query = BoxPGetDatum(box);
  
         switch (strategy)
         {
             case RTOverlapStrategyNumber:
                 flag = DatumGetBool(DirectFunctionCall2(box_overlap, leaf,
                                                         query));
                 break;
  
             case RTContainsStrategyNumber:
                 flag = DatumGetBool(DirectFunctionCall2(box_contain, leaf,
                                                         query));
                 break;
  
             case RTContainedByStrategyNumber:
                 flag = DatumGetBool(DirectFunctionCall2(box_contained, leaf,
                                                         query));
                 break;
  
             case RTSameStrategyNumber:
                 flag = DatumGetBool(DirectFunctionCall2(box_same, leaf,
                                                         query));
                 break;
  
             case RTLeftStrategyNumber:
                 flag = DatumGetBool(DirectFunctionCall2(box_left, leaf,
                                                         query));
                 break;
  
             case RTOverLeftStrategyNumber:
                 flag = DatumGetBool(DirectFunctionCall2(box_overleft, leaf,
                                                         query));
                 break;
  
             case RTRightStrategyNumber:
                 flag = DatumGetBool(DirectFunctionCall2(box_right, leaf,
                                                         query));
                 break;
  
             case RTOverRightStrategyNumber:
                 flag = DatumGetBool(DirectFunctionCall2(box_overright, leaf,
                                                         query));
                 break;
  
             case RTAboveStrategyNumber:
                 flag = DatumGetBool(DirectFunctionCall2(box_above, leaf,
                                                         query));
                 break;
  
             case RTOverAboveStrategyNumber:
                 flag = DatumGetBool(DirectFunctionCall2(box_overabove, leaf,
                                                         query));
                 break;
  
             case RTBelowStrategyNumber:
                 flag = DatumGetBool(DirectFunctionCall2(box_below, leaf,
                                                         query));
                 break;
  
             case RTOverBelowStrategyNumber:
                 flag = DatumGetBool(DirectFunctionCall2(box_overbelow, leaf,
                                                         query));
                 break;
  
             default:
                 elog(ERROR, "unrecognized strategy: %d", strategy);
         }
  
         /* If any check is failed, we have found our answer. */
         if (!flag)
             break;
     }
  
     if (flag && in->norderbys > 0)
     {
         Oid         distfnoid = in->orderbys[0].sk_func.fn_oid;
  
         out->distances = spg_key_orderbys_distances(leaf, false,
                                                     in->orderbys, in->norderbys);
  
         /* Recheck is necessary when computing distance to polygon */
         out->recheckDistances = distfnoid == F_DIST_POLYP;
     }
  
     PG_RETURN_BOOL(flag);
 }

References box_above(), box_below(), box_contain(), box_contained(), box_left(), box_overabove(), box_overbelow(), box_overlap(), box_overleft(), box_overright(), box_right(), box_same(), BoxPGetDatum(), DatumGetBool(), DirectFunctionCall2, spgLeafConsistentOut::distances, elog, ERROR, flag(), FmgrInfo::fn_oid, i, spgLeafConsistentIn::leafDatum, spgLeafConsistentOut::leafValue, spgLeafConsistentIn::nkeys, spgLeafConsistentIn::norderbys, spgLeafConsistentIn::orderbys, PG_GETARG_POINTER, PG_RETURN_BOOL, spgLeafConsistentOut::recheck, spgLeafConsistentOut::recheckDistances, spgLeafConsistentIn::returnData, RTAboveStrategyNumber, RTBelowStrategyNumber, RTContainedByStrategyNumber, RTContainsStrategyNumber, RTLeftStrategyNumber, RTOverAboveStrategyNumber, RTOverBelowStrategyNumber, RTOverlapStrategyNumber, RTOverLeftStrategyNumber, RTOverRightStrategyNumber, RTRightStrategyNumber, RTSameStrategyNumber, spgLeafConsistentIn::scankeys, ScanKeyData::sk_func, ScanKeyData::sk_strategy, spg_box_quad_get_scankey_bbox(), and spg_key_orderbys_distances().

◆ spg_box_quad_picksplit()

Datum spg_box_quad_picksplit ( PG_FUNCTION_ARGS )

Definition at line 441 of file geo_spgist.c.

 {
     spgPickSplitIn *in = (spgPickSplitIn *) PG_GETARG_POINTER(0);
     spgPickSplitOut *out = (spgPickSplitOut *) PG_GETARG_POINTER(1);
     BOX        *centroid;
     int         median,
                 i;
     float8     *lowXs = palloc(sizeof(float8) * in->nTuples);
     float8     *highXs = palloc(sizeof(float8) * in->nTuples);
     float8     *lowYs = palloc(sizeof(float8) * in->nTuples);
     float8     *highYs = palloc(sizeof(float8) * in->nTuples);
  
     /* Calculate median of all 4D coordinates */
     for (i = 0; i < in->nTuples; i++)
     {
         BOX        *box = DatumGetBoxP(in->datums[i]);
  
         lowXs[i] = box->low.x;
         highXs[i] = box->high.x;
         lowYs[i] = box->low.y;
         highYs[i] = box->high.y;
     }
  
     qsort(lowXs, in->nTuples, sizeof(float8), compareDoubles);
     qsort(highXs, in->nTuples, sizeof(float8), compareDoubles);
     qsort(lowYs, in->nTuples, sizeof(float8), compareDoubles);
     qsort(highYs, in->nTuples, sizeof(float8), compareDoubles);
  
     median = in->nTuples / 2;
  
     centroid = palloc(sizeof(BOX));
  
     centroid->low.x = lowXs[median];
     centroid->high.x = highXs[median];
     centroid->low.y = lowYs[median];
     centroid->high.y = highYs[median];
  
     /* Fill the output */
     out->hasPrefix = true;
     out->prefixDatum = BoxPGetDatum(centroid);
  
     out->nNodes = 16;
     out->nodeLabels = NULL;     /* We don't need node labels. */
  
     out->mapTuplesToNodes = palloc(sizeof(int) * in->nTuples);
     out->leafTupleDatums = palloc(sizeof(Datum) * in->nTuples);
  
     /*
      * Assign ranges to corresponding nodes according to quadrants relative to
      * the "centroid" range
      */
     for (i = 0; i < in->nTuples; i++)
     {
         BOX        *box = DatumGetBoxP(in->datums[i]);
         uint8       quadrant = getQuadrant(centroid, box);
  
         out->leafTupleDatums[i] = BoxPGetDatum(box);
         out->mapTuplesToNodes[i] = quadrant;
     }
  
     PG_RETURN_VOID();
 }

References BoxPGetDatum(), compareDoubles(), DatumGetBoxP(), spgPickSplitIn::datums, getQuadrant(), spgPickSplitOut::hasPrefix, BOX::high, i, spgPickSplitOut::leafTupleDatums, BOX::low, spgPickSplitOut::mapTuplesToNodes, spgPickSplitOut::nNodes, spgPickSplitOut::nodeLabels, spgPickSplitIn::nTuples, palloc(), PG_GETARG_POINTER, PG_RETURN_VOID, spgPickSplitOut::prefixDatum, qsort, Point::x, and Point::y.

◆ spg_poly_quad_compress()

Datum spg_poly_quad_compress ( PG_FUNCTION_ARGS )

Definition at line 876 of file geo_spgist.c.

 {
     POLYGON    *polygon = PG_GETARG_POLYGON_P(0);
     BOX        *box;
  
     box = (BOX *) palloc(sizeof(BOX));
     *box = polygon->boundbox;
  
     PG_RETURN_BOX_P(box);
 }

References POLYGON::boundbox, palloc(), PG_GETARG_POLYGON_P, and PG_RETURN_BOX_P.

Data Structures

Functions

Function Documentation

◆ above4D()

◆ below4D()

◆ compareDoubles()

◆ contain2D()

◆ contain4D()

◆ contained2D()

◆ contained4D()

◆ getQuadrant()

◆ getRangeBox()

◆ higher2D()

◆ initRectBox()

◆ is_bounding_box_test_exact()

◆ left4D()

◆ lower2D()

◆ nextRectBox()

◆ overAbove4D()

◆ overBelow4D()

◆ overHigher2D()

◆ overlap2D()

◆ overlap4D()

◆ overLeft4D()

◆ overLower2D()

◆ overRight4D()

◆ pointToRectBoxDistance()

◆ right4D()

◆ spg_bbox_quad_config()

◆ spg_box_quad_choose()

◆ spg_box_quad_config()

◆ spg_box_quad_get_scankey_bbox()

◆ spg_box_quad_inner_consistent()

◆ spg_box_quad_leaf_consistent()

◆ spg_box_quad_picksplit()

◆ spg_poly_quad_compress()