postgis_index_supportfn()

Datum postgis_index_supportfn

(

PG_FUNCTION_ARGS

)

Definition at line 320 of file gserialized_supportfn.c.

{
        Node *rawreq = (Node *) PG_GETARG_POINTER(0);
        Node *ret = NULL;
 
        /* The support function need the cache to be populated to know what the type Oids are.
         * Otherwise it will need look them up dynamically, which only works in the schema where Postgis
         * is installed is part of the search path (Trac #4739)
         */
        postgis_initialize_cache();
 
        if (IsA(rawreq, SupportRequestSelectivity))
        {
                SupportRequestSelectivity *req = (SupportRequestSelectivity *) rawreq;
 
                if (req->is_join)
                {
                        req->selectivity = gserialized_joinsel_internal(req->root, req->args, req->jointype, 2);
                }
                else
                {
                        req->selectivity = gserialized_sel_internal(req->root, req->args, req->varRelid, 2);
                }
                POSTGIS_DEBUGF(2, "%s: got selectivity %g", __func__, req->selectivity);
                PG_RETURN_POINTER(req);
        }
 
        /*
        * This support function is strictly for adding spatial index
        * support.
        */
        if (IsA(rawreq, SupportRequestIndexCondition))
        {
                SupportRequestIndexCondition *req = (SupportRequestIndexCondition *) rawreq;
 
                if (is_funcclause(req->node))   /* ST_Something() */
                {
                        FuncExpr *clause = (FuncExpr *) req->node;
                        Oid funcid = clause->funcid;
                        IndexableFunction idxfn = {NULL, 0, 0, 0, 0};
                        Oid opfamilyoid = req->opfamily; /* OPERATOR FAMILY of the index */
 
                        if (needsSpatialIndex(funcid, &idxfn))
                        {
                                int nargs = list_length(clause->args);
                                Node *leftarg, *rightarg;
                                Oid leftdatatype, rightdatatype, oproid;
                                bool swapped = false;
 
                                /*
                                * Only add an operator condition for GIST, SPGIST, BRIN indexes.
                                * Effectively this means only these opclasses will get automatic
                                * indexing when used with one of the indexable functions
                                * gist_geometry_ops_2d, gist_geometry_ops_nd,
                                * spgist_geometry_ops_2d, spgist_geometry_ops_nd
                                */
                                uint8_t opfamilydims;
                                Oid opfamilyam = opFamilyAmOid(opfamilyoid, &opfamilydims);
                                if (opfamilyam != GIST_AM_OID &&
                                    opfamilyam != SPGIST_AM_OID &&
                                    opfamilyam != BRIN_AM_OID)
                                {
                                        PG_RETURN_POINTER((Node *)NULL);
                                }
 
                                /*
                                * We can only do something with index matches on the first
                                * or second argument.
                                */
                                if (req->indexarg > 1)
                                        PG_RETURN_POINTER((Node *)NULL);
 
                                /*
                                * Avoid using a 3D operator (@@) with a
                                * non-3D function (like ST_Within)
                                * https://trac.osgeo.org/postgis/ticket/5025
                                */
                                if (opfamilydims == 3 && idxfn.dims != 3)
                                        PG_RETURN_POINTER((Node *)NULL);
 
                                /*
                                * Make sure we have enough arguments.
                                */
                                if (nargs < 2 || nargs < idxfn.expand_arg)
                                        elog(ERROR, "%s: associated with function with %d arguments", __func__, nargs);
 
                                /*
                                * Extract "leftarg" as the arg matching
                                * the index and "rightarg" as the other, even if
                                * they were in the opposite order in the call.
                                * NOTE: The functions we deal with here treat
                                * their first two arguments symmetrically
                                * enough that we needn't distinguish between
                                * the two cases beyond this. Could be more
                                * complications in the future.
                                */
                                if (req->indexarg == 0)
                                {
                                        leftarg = linitial(clause->args);
                                        rightarg = lsecond(clause->args);
                                }
                                else
                                {
                                        rightarg = linitial(clause->args);
                                        leftarg = lsecond(clause->args);
                                        swapped = true;
                                }
                                /*
                                * Need the argument types (which should always be geometry/geography) as
                                * this support function is only ever bound to functions
                                * using those types.
                                */
                                leftdatatype = exprType(leftarg);
                                rightdatatype = exprType(rightarg);
 
                                /*
                                * Given the index operator family and the arguments and the
                                * desired strategy number we can now lookup the operator
                                * we want (usually && or &&&).
                                */
                                oproid = get_opfamily_member(opfamilyoid,
                                                             leftdatatype,
                                                             rightdatatype,
                                                             get_strategy_by_type(leftdatatype, idxfn.index));
                                if (!OidIsValid(oproid))
                                        elog(ERROR,
                                             "no spatial operator found for '%s': opfamily %u type %d",
                                             idxfn.fn_name,
                                             opfamilyoid,
                                             leftdatatype);
 
                                /*
                                * For the ST_DWithin variants we need to build a more complex return.
                                * We want to expand the non-indexed side of the call by the
                                * radius and then apply the operator.
                                * st_dwithin(g1, g2, radius) yields this, if g1 is the indexarg:
                                * g1 && st_expand(g2, radius)
                                */
                                if (idxfn.expand_arg)
                                {
                                        Expr *expr;
                                        Node *radiusarg = (Node *) list_nth(clause->args, idxfn.expand_arg-1);
                                        Oid expandfn_oid = expandFunctionOid(rightdatatype, clause->funcid);
 
                                        FuncExpr *expandexpr = makeFuncExpr(expandfn_oid, rightdatatype,
                                            list_make2(rightarg, radiusarg),
                                                InvalidOid, InvalidOid, COERCE_EXPLICIT_CALL);
 
                                        /*
                                        * The comparison expression has to be a pseudo constant,
                                        * (not volatile or dependent on the target index table)
                                        */
#if POSTGIS_PGSQL_VERSION >= 140
                                        if (!is_pseudo_constant_for_index(req->root, (Node*)expandexpr, req->index))
#else
                                        if (!is_pseudo_constant_for_index((Node*)expandexpr, req->index))
#endif
                                                PG_RETURN_POINTER((Node*)NULL);
 
                                        /* OK, we can make an index expression */
                                        expr = make_opclause(oproid, BOOLOID, false,
                                                      (Expr *) leftarg, (Expr *) expandexpr,
                                                      InvalidOid, InvalidOid);
 
                                        ret = (Node *)(list_make1(expr));
                                }
                                /*
                                * For the ST_Intersects variants we just need to return
                                * an index OpExpr with the original arguments on each
                                * side.
                                * st_intersects(g1, g2) yields: g1 && g2
                                */
                                else
                                {
                                        Expr *expr;
                                        /*
                                        * The comparison expression has to be a pseudoconstant
                                        * (not volatile or dependent on the target index's table)
                                        */
#if POSTGIS_PGSQL_VERSION >= 140
                                        if (!is_pseudo_constant_for_index(req->root, rightarg, req->index))
#else
                                        if (!is_pseudo_constant_for_index(rightarg, req->index))
#endif
                                                PG_RETURN_POINTER((Node*)NULL);
 
                                        /*
                                        * Arguments were swapped to put the index value on the
                                        * left, so we need the commuted operator for
                                        * the OpExpr
                                        */
                                        if (swapped)
                                        {
                                                oproid = get_commutator(oproid);
                                                if (!OidIsValid(oproid))
                                                        PG_RETURN_POINTER((Node *)NULL);
                                        }
 
                                        expr = make_opclause(oproid, BOOLOID, false,
                                                        (Expr *) leftarg, (Expr *) rightarg,
                                                        InvalidOid, InvalidOid);
 
                                        ret = (Node *)(list_make1(expr));
                                }
 
                                /*
                                * Set the lossy field on the SupportRequestIndexCondition parameter
                                * to indicate that the index alone is not sufficient to evaluate
                                * the condition. The function must also still be applied.
                                */
                                req->lossy = true;
 
                                PG_RETURN_POINTER(ret);
                        }
                        else
                        {
                                elog(WARNING, "support function '%s' called from unsupported spatial function", __func__);
                        }
                }
        }
 
        PG_RETURN_POINTER(ret);
}

References IndexableFunction::dims, IndexableFunction::expand_arg, expandFunctionOid(), IndexableFunction::fn_name, get_strategy_by_type(), gserialized_joinsel_internal(), gserialized_sel_internal(), IndexableFunction::index, needsSpatialIndex(), and opFamilyAmOid().

Here is the call graph for this function: