gserialized_spgist_inner_consistent_nd()

PGDLLEXPORT Datum gserialized_spgist_inner_consistent_nd

(

PG_FUNCTION_ARGS

)

Definition at line 396 of file gserialized_spgist_nd.c.

{
        spgInnerConsistentIn *in = (spgInnerConsistentIn *)PG_GETARG_POINTER(0);
        spgInnerConsistentOut *out = (spgInnerConsistentOut *)PG_GETARG_POINTER(1);
        MemoryContext old_ctx;
        CubeGIDX *cube_box;
        int *nodeNumbers, i, j;
        void **traversalValues;
        char gidxmem[GIDX_MAX_SIZE];
        GIDX *centroid, *query_gbox_index = (GIDX *)gidxmem;
 
        POSTGIS_DEBUG(4, "[SPGIST] 'inner consistent' function called");
 
        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 switch memory context, because we want to allocate memory for new
         * traversal values (next_cube_box) and pass these pieces of memory to
         * further call of this function.
         */
        old_ctx = MemoryContextSwitchTo(in->traversalMemoryContext);
 
        centroid = (GIDX *)DatumGetPointer(in->prefixDatum);
 
        /*
         * We are saving the traversal value or initialize it an unbounded one, if
         * we have just begun to walk the tree.
         */
        if (in->traversalValue)
                cube_box = in->traversalValue;
        else
                cube_box = initCubeBox(GIDX_NDIMS(centroid));
 
        /* Allocate enough memory for nodes */
        out->nNodes = 0;
        nodeNumbers = (int *)palloc(sizeof(int) * in->nNodes);
        traversalValues = (void **)palloc(sizeof(void *) * in->nNodes);
 
        for (i = 0; i < in->nNodes; i++)
        {
                CubeGIDX *next_cube_box = nextCubeBox(cube_box, centroid, (uint16_t)i);
                bool flag = true;
 
                for (j = 0; j < in->nkeys; j++)
                {
                        StrategyNumber strategy = in->scankeys[j].sk_strategy;
                        Datum query = in->scankeys[j].sk_argument;
 
                        /* Quick sanity check on query argument. */
                        if (DatumGetPointer(query) == NULL)
                        {
                                POSTGIS_DEBUG(4, "[SPGIST] null query pointer (!?!)");
                                flag = false;
                                break;
                        }
 
                        /* Null box should never make this far. */
                        if (gserialized_datum_get_gidx_p(query, query_gbox_index) == LW_FAILURE)
                        {
                                POSTGIS_DEBUG(4, "[SPGIST] null query_gbox_index!");
                                flag = false;
                                break;
                        }
 
                        switch (strategy)
                        {
                        case SPGOverlapStrategyNumber:
                        case SPGContainedByStrategyNumber:
                                flag = overlapND(next_cube_box, query_gbox_index);
                                break;
 
                        case SPGContainsStrategyNumber:
                        case SPGSameStrategyNumber:
                                flag = containND(next_cube_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)
                {
                        traversalValues[out->nNodes] = next_cube_box;
                        nodeNumbers[out->nNodes] = i;
                        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_cube_box);
                }
        }
 
        /* Pass to the next level only the values that need to be traversed */
        out->nodeNumbers = (int *)palloc(sizeof(int) * out->nNodes);
        out->traversalValues = (void **)palloc(sizeof(void *) * out->nNodes);
        for (i = 0; i < out->nNodes; i++)
        {
                out->nodeNumbers[i] = nodeNumbers[i];
                out->traversalValues[i] = traversalValues[i];
        }
        pfree(nodeNumbers);
        pfree(traversalValues);
 
        /* Switch after */
        MemoryContextSwitchTo(old_ctx);
 
        PG_RETURN_VOID();
}

References centroid(), containND(), initCubeBox(), LW_FAILURE, nextCubeBox(), overlapND(), SPGContainedByStrategyNumber, SPGContainsStrategyNumber, SPGOverlapStrategyNumber, and SPGSameStrategyNumber.

Here is the call graph for this function: