返回有关索引实现的静态信息，包括前缀和节点标签数据类型的数据类型 OID。

SQL函数的声明必须如下所示

CREATE FUNCTION my_config(internal, internal) RETURNS void ...

第一个参数是指向 spgConfigIn C 结构体的指针，其中包含函数的输入数据。第二个参数是指向 spgConfigOut C 结构体的指针，函数必须使用结果数据填充该结构体。

typedef struct spgConfigIn
{
    Oid         attType;        /* Data type to be indexed */
} spgConfigIn;

typedef struct spgConfigOut
{
    Oid         prefixType;     /* Data type of inner-tuple prefixes */
    Oid         labelType;      /* Data type of inner-tuple node labels */
    Oid         leafType;       /* Data type of leaf-tuple values */
    bool        canReturnData;  /* Opclass can reconstruct original data */
    bool        longValuesOK;   /* Opclass can cope with values > 1 page */
} spgConfigOut;

传递 attType 是为了支持多态索引操作符类；对于普通的固定数据类型操作符类，它将始终具有相同的值，因此可以忽略。

对于不使用前缀的操作符类，可以将 prefixType 设置为 VOIDOID。 同样，对于不使用节点标签的操作符类，可以将 labelType 设置为 VOIDOID。 如果操作符类能够重建最初提供的索引值，则应将 canReturnData 设置为 true。 仅当 attType 的类型是可变长度，并且操作符类能够通过重复添加后缀来分割长值时，才应将 longValuesOK 设置为 true（请参阅 第 64.3.4.1 节）。

leafType 应该与操作符类的 opckeytype 目录条目定义的索引存储类型匹配。（请注意，opckeytype 可以为零，表示存储类型与操作符类的输入类型相同，这是最常见的情况。）出于向后兼容的原因，config 方法可以将 leafType 设置为其他值，并且将使用该值；但这已被弃用，因为索引内容在目录中会被错误地识别。此外，允许将 leafType 保持未初始化（零）；这被解释为表示索引存储类型从 opckeytype 派生而来。

当 attType 和 leafType 不同时，必须提供可选方法 compress。方法 compress 负责将要索引的数据从 attType 转换为 leafType。

选择一种将新值插入到内部元组的方法。

SQL函数的声明必须如下所示

CREATE FUNCTION my_choose(internal, internal) RETURNS void ...

第一个参数是指向 spgChooseIn C 结构体的指针，其中包含该函数的输入数据。第二个参数是指向 spgChooseOut C 结构体的指针，该函数必须用结果数据填充该结构体。

typedef struct spgChooseIn
{
    Datum       datum;          /* original datum to be indexed */
    Datum       leafDatum;      /* current datum to be stored at leaf */
    int         level;          /* current level (counting from zero) */

    /* Data from current inner tuple */
    bool        allTheSame;     /* tuple is marked all-the-same? */
    bool        hasPrefix;      /* tuple has a prefix? */
    Datum       prefixDatum;    /* if so, the prefix value */
    int         nNodes;         /* number of nodes in the inner tuple */
    Datum      *nodeLabels;     /* node label values (NULL if none) */
} spgChooseIn;

typedef enum spgChooseResultType
{
    spgMatchNode = 1,           /* descend into existing node */
    spgAddNode,                 /* add a node to the inner tuple */
    spgSplitTuple               /* split inner tuple (change its prefix) */
} spgChooseResultType;

typedef struct spgChooseOut
{
    spgChooseResultType resultType;     /* action code, see above */
    union
    {
        struct                  /* results for spgMatchNode */
        {
            int         nodeN;      /* descend to this node (index from 0) */
            int         levelAdd;   /* increment level by this much */
            Datum       restDatum;  /* new leaf datum */
        }           matchNode;
        struct                  /* results for spgAddNode */
        {
            Datum       nodeLabel;  /* new node's label */
            int         nodeN;      /* where to insert it (index from 0) */
        }           addNode;
        struct                  /* results for spgSplitTuple */
        {
            /* Info to form new upper-level inner tuple with one child tuple */
            bool        prefixHasPrefix;    /* tuple should have a prefix? */
            Datum       prefixPrefixDatum;  /* if so, its value */
            int         prefixNNodes;       /* number of nodes */
            Datum      *prefixNodeLabels;   /* their labels (or NULL for
                                             * no labels) */
            int         childNodeN;         /* which node gets child tuple */

            /* Info to form new lower-level inner tuple with all old nodes */
            bool        postfixHasPrefix;   /* tuple should have a prefix? */
            Datum       postfixPrefixDatum; /* if so, its value */
        }           splitTuple;
    }           result;
} spgChooseOut;

datum 是 spgConfigIn.attType 类型的原始数据，该数据将被插入到索引中。leafDatum 是 spgConfigOut.leafType 类型的值，如果提供了方法 compress，则该值最初是应用 compress 方法对 datum 的结果，否则与 datum 的值相同。如果 choose 或 picksplit 方法更改了 leafDatum，则树的较低级别可能会更改 leafDatum。当插入搜索到达叶子页时，leafDatum 的当前值将存储在新建的叶子元组中。level 是当前内部元组的级别，根级别的起始值为零。如果当前内部元组被标记为包含多个等效节点，则 allTheSame 为 true（请参阅 第 64.3.4.3 节）。如果当前内部元组包含前缀，则 hasPrefix 为 true；如果是，则 prefixDatum 是其值。nNodes 是内部元组中包含的子节点数量，nodeLabels 是它们的标签值数组，如果没有标签，则为 NULL。

choose 函数可以确定新值是否与现有子节点之一匹配，或者必须添加新的子节点，或者新值与元组前缀不一致，因此必须分割内部元组以创建限制性较少的前缀。

如果新值与现有子节点之一匹配，则将 resultType 设置为 spgMatchNode。将 nodeN 设置为节点数组中该节点的索引（从零开始）。将 levelAdd 设置为通过下降该节点而导致的 level 的增量，如果操作符类不使用级别，则将其保留为零。如果操作符类不修改从一个级别到下一个级别的数据，则将 restDatum 设置为等于 leafDatum，否则将其设置为将用作下一级的 leafDatum 的修改值。

如果必须添加新的子节点，则将 resultType 设置为 spgAddNode。将 nodeLabel 设置为新节点要使用的标签，并将 nodeN 设置为在节点数组中插入节点的索引（从零开始）。添加节点后，将再次调用 choose 函数，并使用修改后的内部元组；该调用应产生 spgMatchNode 结果。

如果新值与元组前缀不一致，则将 resultType 设置为 spgSplitTuple。此操作将所有现有节点移动到新的较低级别内部元组中，并将现有内部元组替换为具有指向新较低级别内部元组的单个下行链路的元组。设置 prefixHasPrefix 以指示新的上层元组是否应具有前缀，如果应具有前缀，则将 prefixPrefixDatum 设置为前缀值。这个新的前缀值必须比原来的限制性小得多，才能接受要索引的新值。将 prefixNNodes 设置为新元组中需要的节点数，并将 prefixNodeLabels 设置为保存其标签的 palloc'd 数组，如果不需要节点标签，则设置为 NULL。请注意，新的上层元组的总大小不得超过它所替换的元组的总大小；这限制了新前缀和新标签的长度。将 childNodeN 设置为将下行链路到新的较低级别内部元组的节点的索引（从零开始）。设置 postfixHasPrefix 以指示新的较低级别内部元组是否应具有前缀，如果应具有前缀，则将 postfixPrefixDatum 设置为前缀值。这两个前缀和下行链路节点的标签（如果有）的组合必须与原始前缀具有相同的含义，因为没有机会更改移动到新的较低级别元组的节点标签，也无法更改任何子索引条目。分割节点后，将使用替换的内部元组再次调用 choose 函数。如果没有 spgSplitTuple 操作创建合适的节点，则该调用可能会返回 spgAddNode 结果。最终，choose 必须返回 spgMatchNode，以允许插入下降到下一级别。

决定如何在一组叶子元组上创建新的内部元组。

SQL函数的声明必须如下所示

CREATE FUNCTION my_picksplit(internal, internal) RETURNS void ...

第一个参数是指向 spgPickSplitIn C 结构体的指针，其中包含该函数的输入数据。第二个参数是指向 spgPickSplitOut C 结构体的指针，该函数必须用结果数据填充该结构体。

typedef struct spgPickSplitIn
{
    int         nTuples;        /* number of leaf tuples */
    Datum      *datums;         /* their datums (array of length nTuples) */
    int         level;          /* current level (counting from zero) */
} spgPickSplitIn;

typedef struct spgPickSplitOut
{
    bool        hasPrefix;      /* new inner tuple should have a prefix? */
    Datum       prefixDatum;    /* if so, its value */

    int         nNodes;         /* number of nodes for new inner tuple */
    Datum      *nodeLabels;     /* their labels (or NULL for no labels) */

    int        *mapTuplesToNodes;   /* node index for each leaf tuple */
    Datum      *leafTupleDatums;    /* datum to store in each new leaf tuple */
} spgPickSplitOut;

nTuples 是提供的叶子元组的数量。datums 是它们 spgConfigOut.leafType 类型的数据值数组。level 是所有叶子元组共享的当前级别，这将成为新内部元组的级别。

设置 hasPrefix 以指示新的内部元组是否应具有前缀，如果应具有前缀，则将 prefixDatum 设置为前缀值。设置 nNodes 以指示新内部元组将包含的节点数，并将 nodeLabels 设置为它们的标签值数组，如果不需要节点标签，则设置为 NULL。将 mapTuplesToNodes 设置为一个数组，该数组给出了每个叶子元组应分配到的节点的索引（从零开始）。将 leafTupleDatums 设置为一个数组，其中包含要存储在新叶子元组中的值（如果操作符类不修改从一个级别到下一个级别的数据，则这些值将与输入 datums 相同）。请注意，picksplit 函数负责 palloc'ing nodeLabels、mapTuplesToNodes 和 leafTupleDatums 数组。

如果提供了多个叶子元组，则期望 picksplit 函数将它们分类为多个节点；否则，不可能跨多个页面分割叶子元组，这是此操作的最终目的。因此，如果 picksplit 函数最终将所有叶子元组放置在同一个节点中，则核心 SP-GiST 代码将覆盖该决定，并生成一个内部元组，其中叶子元组被随机分配给几个标签相同的节点。这样的元组被标记为 allTheSame，表示这种情况已经发生。 choose 和 inner_consistent 函数必须适当处理此类内部元组。有关更多信息，请参阅 第 64.3.4.3 节。

仅当 config 函数将 longValuesOK 设置为 true 并且提供了大于页面的输入值时，才能将 picksplit 应用于单个叶子元组。在这种情况下，操作的目的是剥离前缀并生成新的、较短的叶子数据值。将重复调用该操作，直到生成足够短以适合页面的叶子数据。有关更多信息，请参阅 第 64.3.4.1 节。

返回在树搜索期间要遵循的节点（分支）集。

SQL函数的声明必须如下所示

CREATE FUNCTION my_inner_consistent(internal, internal) RETURNS void ...

第一个参数是指向 spgInnerConsistentIn C 结构体的指针，其中包含该函数的输入数据。第二个参数是指向 spgInnerConsistentOut C 结构体的指针，该函数必须用结果数据填充该结构体。

typedef struct spgInnerConsistentIn
{
    ScanKey     scankeys;       /* array of operators and comparison values */
    ScanKey     orderbys;       /* array of ordering operators and comparison
                                 * values */
    int         nkeys;          /* length of scankeys array */
    int         norderbys;      /* length of orderbys array */

    Datum       reconstructedValue;     /* value reconstructed at parent */
    void       *traversalValue; /* opclass-specific traverse value */
    MemoryContext traversalMemoryContext;   /* put new traverse values here */
    int         level;          /* current level (counting from zero) */
    bool        returnData;     /* original data must be returned? */

    /* Data from current inner tuple */
    bool        allTheSame;     /* tuple is marked all-the-same? */
    bool        hasPrefix;      /* tuple has a prefix? */
    Datum       prefixDatum;    /* if so, the prefix value */
    int         nNodes;         /* number of nodes in the inner tuple */
    Datum      *nodeLabels;     /* node label values (NULL if none) */
} spgInnerConsistentIn;

typedef struct spgInnerConsistentOut
{
    int         nNodes;         /* number of child nodes to be visited */
    int        *nodeNumbers;    /* their indexes in the node array */
    int        *levelAdds;      /* increment level by this much for each */
    Datum      *reconstructedValues;    /* associated reconstructed values */
    void      **traversalValues;        /* opclass-specific traverse values */
    double    **distances;              /* associated distances */
} spgInnerConsistentOut;

长度为 nkeys 的数组 scankeys 描述了索引搜索条件。这些条件通过 AND 组合在一起 — 只有满足所有条件的索引条目才相关。（请注意，nkeys = 0 表示所有索引条目都满足查询。）通常，一致性函数只关心每个数组条目的 sk_strategy 和 sk_argument 字段，它们分别给出了可索引的操作符和比较值。特别是，没有必要检查 sk_flags 来查看比较值是否为 NULL，因为 SP-GiST 核心代码会过滤掉此类条件。长度为 norderbys 的数组 orderbys 以相同的方式描述了排序操作符（如果有）。reconstructedValue 是为父元组重建的值；在根级别或当 inner_consistent 函数未在父级别提供值时，其值为 (Datum) 0。traversalValue 是一个指向从上一次对父索引元组调用 inner_consistent 传递下来的任何遍历数据的指针，如果在根级别则为 NULL。traversalMemoryContext 是存储输出遍历值的内存上下文（见下文）。level 是当前内部元组的级别，根级别从零开始。returnData 是 true，如果此查询需要重建的数据；仅当 config 函数断言 canReturnData 时，才会如此。allTheSame 为 true，如果当前内部元组被标记为 “全部相同”；在这种情况下，所有节点都具有相同的标签（如果有），因此它们要么全部匹配查询，要么全部不匹配查询（请参阅 第 64.3.4.3 节）。hasPrefix 为 true，如果当前内部元组包含前缀；如果是这样，则 prefixDatum 是其值。nNodes 是内部元组中包含的子节点数，而 nodeLabels 是其标签值的数组，如果节点没有标签则为 NULL。

nNodes 必须设置为搜索需要访问的子节点数，nodeNumbers 必须设置为其索引的数组。如果操作符类跟踪级别，则将 levelAdds 设置为下降到要访问的每个节点时所需的级别增量的数组。（通常这些增量对于所有节点都是相同的，但并非必须如此，因此使用数组。）如果需要值重建，则将 reconstructedValues 设置为为每个要访问的子节点重建的值的数组；否则，将 reconstructedValues 保留为 NULL。假定重建值的类型为 spgConfigOut.leafType。（但是，由于核心系统除了可能复制它们外不会对它们执行任何操作，因此只要它们具有与 leafType 相同的 typlen 和 typbyval 属性就足够了。）如果执行有序搜索，则根据 orderbys 数组将 distances 设置为距离值的数组（将首先处理距离最小的节点）。否则，将其保留为 NULL。如果希望将额外的带外信息（“遍历值”）传递到树搜索的较低级别，请将 traversalValues 设置为相应遍历值的数组，每个要访问的子节点一个；否则，将 traversalValues 保留为 NULL。请注意，inner_consistent 函数负责在当前内存上下文中 palloc nodeNumbers、levelAdds、distances、reconstructedValues 和 traversalValues 数组。但是，traversalValues 数组指向的任何输出遍历值都应在 traversalMemoryContext 中分配。每个遍历值都必须是单个 palloc'd 块。

如果叶元组满足查询，则返回 true。

SQL函数的声明必须如下所示

CREATE FUNCTION my_leaf_consistent(internal, internal) RETURNS bool ...

第一个参数是指向 spgLeafConsistentIn C 结构的指针，其中包含该函数的输入数据。第二个参数是指向 spgLeafConsistentOut C 结构的指针，函数必须使用结果数据填充该结构。

typedef struct spgLeafConsistentIn
{
    ScanKey     scankeys;       /* array of operators and comparison values */
    ScanKey     orderbys;       /* array of ordering operators and comparison
                                 * values */
    int         nkeys;          /* length of scankeys array */
    int         norderbys;      /* length of orderbys array */

    Datum       reconstructedValue;     /* value reconstructed at parent */
    void       *traversalValue; /* opclass-specific traverse value */
    int         level;          /* current level (counting from zero) */
    bool        returnData;     /* original data must be returned? */

    Datum       leafDatum;      /* datum in leaf tuple */
} spgLeafConsistentIn;

typedef struct spgLeafConsistentOut
{
    Datum       leafValue;        /* reconstructed original data, if any */
    bool        recheck;          /* set true if operator must be rechecked */
    bool        recheckDistances; /* set true if distances must be rechecked */
    double     *distances;        /* associated distances */
} spgLeafConsistentOut;

长度为 nkeys 的数组 scankeys 描述了索引搜索条件。这些条件通过 AND 组合在一起 — 只有满足所有条件的索引条目才满足查询。（请注意，nkeys = 0 表示所有索引条目都满足查询。）通常，一致性函数只关心每个数组条目的 sk_strategy 和 sk_argument 字段，它们分别给出了可索引的操作符和比较值。特别是，没有必要检查 sk_flags 来查看比较值是否为 NULL，因为 SP-GiST 核心代码会过滤掉此类条件。长度为 norderbys 的数组 orderbys 以相同的方式描述了排序操作符。reconstructedValue 是为父元组重建的值；在根级别或当 inner_consistent 函数未在父级别提供值时，其值为 (Datum) 0。traversalValue 是一个指向从上一次对父索引元组调用 inner_consistent 传递下来的任何遍历数据的指针，如果在根级别则为 NULL。level 是当前叶元组的级别，根级别从零开始。returnData 是 true，如果此查询需要重建的数据；仅当 config 函数断言 canReturnData 时，才会如此。leafDatum 是存储在当前叶元组中的 spgConfigOut.leafType 的键值。

如果叶元组与查询匹配，则函数必须返回 true，否则返回 false。在 true 的情况下，如果 returnData 为 true，则 leafValue 必须设置为最初为该叶元组提供的索引值（类型为 spgConfigIn.attType）。此外，如果匹配不确定，因此必须将操作符重新应用于实际堆元组以验证匹配，则可以将 recheck 设置为 true。如果执行有序搜索，则根据 orderbys 数组将 distances 设置为距离值的数组。否则，将其保留为 NULL。如果至少有一个返回的距离不准确，则将 recheckDistances 设置为 true。在这种情况下，执行器将在从堆中获取元组后计算确切的距离，并将在需要时重新排序元组。

将数据项转换为适合在索引的叶元组中进行物理存储的格式。它接受 spgConfigIn.attType 类型的值，并返回 spgConfigOut.leafType 类型的值。输出值不能包含超出行的 TOAST 指针。

注意：compress 方法仅应用于要存储的值。一致性方法接收未更改的查询 scankeys，而无需使用 compress 进行转换。

定义一组用户可见的参数，用于控制操作符类的行为。

SQL函数的声明必须如下所示

CREATE OR REPLACE FUNCTION my_options(internal)
RETURNS void
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT;

该函数会传递一个指向 local_relopts 结构的指针，该结构需要使用一组特定于操作符类的选项进行填充。可以使用 PG_HAS_OPCLASS_OPTIONS() 和 PG_GET_OPCLASS_OPTIONS() 宏从其他支持函数访问这些选项。

由于键的表示形式为SP-GiST是灵活的，因此它可能取决于用户指定的参数。