gserialized_spgist_inner_consistent_3d()

PGDLLEXPORT Datum gserialized_spgist_inner_consistent_3d

(

PG_FUNCTION_ARGS

)

Definition at line 505 of file gserialized_spgist_3d.c.

{
        spgInnerConsistentIn *in = (spgInnerConsistentIn *)PG_GETARG_POINTER(0);
        spgInnerConsistentOut *out = (spgInnerConsistentOut *)PG_GETARG_POINTER(1);
        int i;
        MemoryContext old_ctx;
        CubeBox3D *cube_box;
        uint8 octant;
        BOX3D *centroid;
        int *nodeNumbers;
        void **traversalValues;
 
        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)
                cube_box = in->traversalValue;
        else
                cube_box = initCubeBox();
 
        centroid = DatumGetBox3DP(in->prefixDatum);
 
        /* Allocate enough memory for nodes */
        out->nNodes = 0;
        nodeNumbers = (int *)palloc(sizeof(int) * in->nNodes);
        traversalValues = (void **)palloc(sizeof(void *) * in->nNodes);
 
        /*
         * 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);
 
        for (octant = 0; octant < in->nNodes; octant++)
        {
                CubeBox3D *next_cube_box = nextCubeBox3D(cube_box, centroid, octant);
                bool flag = true;
 
                for (i = 0; i < in->nkeys; i++)
                {
                        StrategyNumber strategy = in->scankeys[i].sk_strategy;
                        Datum query = in->scankeys[i].sk_argument;
                        BOX3D *box = DatumGetBox3DP(DirectFunctionCall1(LWGEOM_to_BOX3D, query));
 
                        switch (strategy)
                        {
                        case SPGOverlapStrategyNumber:
                        case SPGContainedByStrategyNumber:
                                flag = overlap6D(next_cube_box, box);
                                break;
 
                        case SPGContainsStrategyNumber:
                        case SPGSameStrategyNumber:
                                flag = contain6D(next_cube_box, box);
                                break;
 
                        case SPGLeftStrategyNumber:
                                flag = !overRight6D(next_cube_box, box);
                                break;
 
                        case SPGOverLeftStrategyNumber:
                                flag = !right6D(next_cube_box, box);
                                break;
 
                        case SPGRightStrategyNumber:
                                flag = !overLeft6D(next_cube_box, box);
                                break;
 
                        case SPGOverRightStrategyNumber:
                                flag = !left6D(next_cube_box, box);
                                break;
 
                        case SPGAboveStrategyNumber:
                                flag = !overBelow6D(next_cube_box, box);
                                break;
 
                        case SPGOverAboveStrategyNumber:
                                flag = !below6D(next_cube_box, box);
                                break;
 
                        case SPGBelowStrategyNumber:
                                flag = !overAbove6D(next_cube_box, box);
                                break;
 
                        case SPGOverBelowStrategyNumber:
                                flag = !above6D(next_cube_box, box);
                                break;
 
                        case SPGBackStrategyNumber:
                                flag = !overFront6D(next_cube_box, box);
                                break;
 
                        case SPGOverBackStrategyNumber:
                                flag = !front6D(next_cube_box, box);
                                break;
 
                        case SPGFrontStrategyNumber:
                                flag = !overBack6D(next_cube_box, box);
                                break;
 
                        case SPGOverFrontStrategyNumber:
                                flag = !back6D(next_cube_box, box);
                                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] = octant;
                        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 above6D(), back6D(), below6D(), centroid(), contain6D(), front6D(), initCubeBox(), left6D(), LWGEOM_to_BOX3D(), nextCubeBox3D(), overAbove6D(), overBack6D(), overBelow6D(), overFront6D(), overlap6D(), overLeft6D(), overRight6D(), right6D(), SPGAboveStrategyNumber, SPGBackStrategyNumber, SPGBelowStrategyNumber, SPGContainedByStrategyNumber, SPGContainsStrategyNumber, SPGFrontStrategyNumber, SPGLeftStrategyNumber, SPGOverAboveStrategyNumber, SPGOverBackStrategyNumber, SPGOverBelowStrategyNumber, SPGOverFrontStrategyNumber, SPGOverlapStrategyNumber, SPGOverLeftStrategyNumber, SPGOverRightStrategyNumber, SPGRightStrategyNumber, and SPGSameStrategyNumber.

Here is the call graph for this function: