gserialized_spgist_inner_consistent_2d()

PGDLLEXPORT Datum gserialized_spgist_inner_consistent_2d

(

PG_FUNCTION_ARGS

)

Definition at line 408 of file gserialized_spgist_2d.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;
        BOX2DF *centroid;
 
        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;
 
                PG_RETURN_VOID();
        }
 
        /*
         * 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();
 
        centroid = (BOX2DF *)DatumGetPointer(in->prefixDatum);
 
        /* Allocate enough memory for nodes */
        out->nNodes = 0;
        out->nodeNumbers = (int *)palloc(sizeof(int) * in->nNodes);
        out->traversalValues = (void **)palloc(sizeof(void *) * 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 < (uint8)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;
 
                        Datum query = in->scankeys[i].sk_argument;
                        BOX2DF query_gbox_index;
 
                        /* Quick sanity check on query argument. */
                        if (DatumGetPointer(query) == NULL)
                        {
                                POSTGIS_DEBUG(4, "[SPGIST] null query pointer (!?!), returning false");
                                PG_RETURN_BOOL(false); /* NULL query! This is screwy! */
                        }
 
                        if (gserialized_datum_get_box2df_p(query, &query_gbox_index) == LW_FAILURE)
                        {
                                POSTGIS_DEBUG(4, "[SPGIST] null query_gbox_index!");
                                PG_RETURN_BOOL(false);
                        }
 
                        switch (strategy)
                        {
                        case RTOverlapStrategyNumber:
                        case RTContainedByStrategyNumber:
                        case RTOldContainedByStrategyNumber:
                                flag = overlap4D(next_rect_box, &query_gbox_index);
                                break;
 
                        case RTContainsStrategyNumber:
                        case RTSameStrategyNumber:
                                flag = contain4D(next_rect_box, &query_gbox_index);
                                break;
 
                        case RTLeftStrategyNumber:
                                flag = !overRight4D(next_rect_box, &query_gbox_index);
                                break;
 
                        case RTOverLeftStrategyNumber:
                                flag = !right4D(next_rect_box, &query_gbox_index);
                                break;
 
                        case RTRightStrategyNumber:
                                flag = !overLeft4D(next_rect_box, &query_gbox_index);
                                break;
 
                        case RTOverRightStrategyNumber:
                                flag = !left4D(next_rect_box, &query_gbox_index);
                                break;
 
                        case RTAboveStrategyNumber:
                                flag = !overBelow4D(next_rect_box, &query_gbox_index);
                                break;
 
                        case RTOverAboveStrategyNumber:
                                flag = !below4D(next_rect_box, &query_gbox_index);
                                break;
 
                        case RTBelowStrategyNumber:
                                flag = !overAbove4D(next_rect_box, &query_gbox_index);
                                break;
 
                        case RTOverBelowStrategyNumber:
                                flag = !above4D(next_rect_box, &query_gbox_index);
                                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;
                        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 after */
        MemoryContextSwitchTo(old_ctx);
 
        PG_RETURN_VOID();
}

References above4D(), below4D(), centroid(), contain4D(), gserialized_datum_get_box2df_p(), initRectBox(), left4D(), LW_FAILURE, nextRectBox(), overAbove4D(), overBelow4D(), overlap4D(), overLeft4D(), overRight4D(), and right4D().

Here is the call graph for this function: