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

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

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

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

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是可变长度且运算符类能够通过重复后缀对长值进行分割（见64.3.4.1 节）时，应仅将longValuesOK设置为 true。

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 方法，则一开始是应用于 datum 的 compress 方法的结果，否则就是和 datum 相同的值。如果 choose 或者 picksplit 方法改变了 leafDatum，它可以在树的较低层级发生改变。当插入搜索到达叶页面，leafDatum 当前的值将被存储在新建的叶元组中。 level 是当前内元组的层级，从根层级的零开始。 allTheSame 在当前内元组被标记为包含多个等效节点时为真（参见 第 64.3.4.3 节）。 hasPrefix 在当前内元组包含一个前缀时为真；如果是，则 prefixDatum 是其值。 nNodes 是内元组包含的子节点的数量，nodeLabels 是一个包含其标签值或者在没有标签时为 NULL 的数组。

choose 函数可以判断新值是否匹配某个现有的子节点，或者必须添加一个新的子节点，或者新值与元组前缀不一致，因此内元组必须被切分为一个限制性较小的前缀。

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

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

如果新值与元组前缀不一致，请将 resultType 设置为 spgSplitTuple。此操作会将所有现有节点移动到新的较低级别内嵌元组中，并使用指向新的较低级别内嵌元组的单一下行链路替换现有的内嵌元组。设置 prefixHasPrefix 以指示新上层元组是否应该有前缀，如果应有前缀，则设置 prefixPrefixDatum 为前缀值。此新前缀值必须比原始值限制性低才能接受要索引的新值。将 prefixNNodes 设置为新元组中所需的节点数，并将 prefixNodeLabels 设置为保存其标签的 palloc 数组，如果没有节点标签要求，则设置为 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 相同)。请注意,负责 palloc 的 picksplit 函数数组 nodeLabels, mapTuplesToNodes 和 leafTupleDatums。

如果提供了多个叶元组,则期望 picksplit 函数会将它们分类到多个节点中;否则,不能将叶元组拆分到多个页面中,这是此操作的最终目的。因此,如果 picksplit 函数最终将所有叶元组放在同一节点中,核心 SP-GiST 代码将替代该决策,并生成内部元组,其中叶元组被随机分配到几个标签相同的节点中。这种元组标记为 allTheSame 以表明发生了这种情况。 choose 和 inner_consistent 函数必须对这种内部元组采取适当的注意。有关更多信息,请参见 第 64.3.4.3 节。

picksplit 只能对单个叶元组应用,在 config 函数将 longValuesOK 设置为 true 并且已经提供了大于页的大于页输入值的情况下。在这种情况下,操作的目的是剥离前缀,并生成新的更短的叶数据值。该调用将重复,直到生成足够短的叶数据来适应页面为止。有关更多信息,请参见 第 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，描述了索引搜索条件。这些条件是和操作结合在一起的，仅同时满足所有条件的索引条目才具有价值（注意 nkeys = 0 表示所有索引条目都满足查询）。通常，一致性函数只关心每个数组条目的 sk_strategy 和 sk_argument 域，它们分别给出可索引运算符和比较值。特别地，无需查看 sk_flags 来判断比较值是否为 NULL，因为 SP-GiST 内核代码会过滤掉此类条件。长度为 norderbys 的数组 orderbys，以相同方式描述排序运算符（如果有）。reconstructedValue 是为父 tuple 重建的值；在根级别或如果 inner_consistent 函数未在父级别提供值，则该值为 (Datum) 0。traversalValue 是指向从 inner_consistent 在父索引 tuple 上前次回调传递下来的任何遍历数据的指针，或在根级别为 NULL。traversalMemoryContext 是用来存储输出遍历值（见下文）的内存环境。level 是当前内部 tuple 的级别，根级别的起始值为零。returnData 在本查询需要重构数据时为 true；当且仅当 config 函数断言 canReturnData 时才成立。allTheSame 在当前内部 tuple 被标记为 “all-the-same” 时为 true；在此情况下，所有节点都有相同的标签（如果有），因此所有节点都匹配查询，或者没有节点匹配查询（见 第 64.3.4.3 节）。hasPrefix 在当前内部 tuple 包含前缀时为 true；如果包含，prefixDatum 是其值。nNodes 是内部 tuple 中包含的子节点数，nodeLabels 是其标签值的数组，如果节点没有标签，则该数组为 NULL。

nNodes 必须设置为需要被搜索访问的子节点数，nodeNumbers 必须设置为一个数组，用于存储它们的索引。如果运算符类追踪级别，将 levelAdds 设置为当降级到每个待访问节点时所需的级别增量数组。（通常这些增量对于所有节点而言都是相同的，但并非必然如此，因此使用了一个数组。）如果需要值重构，设置 reconstructedValues 为一个待访问的每个子节点重构的值数组；如果不，让 reconstructedValues 保持为 NULL。重构的值被认为是 spgConfigOut.leafType 类型。（然而，因为核心系统除了可能复制它们之外对它们不做任何操作，因此只需要它们拥有与 leafType 相同的 typlen 和 typbyval 属性即可。）如果执行有序搜索，根据 orderbys 数组将 distances 设置为一个距离值数组（具有最小距离的节点将被首先处理）。否则让它为 NULL。如果想要将附加的带外信息（“遍历值”）向下传递到树搜索的较低层级，将 traversalValues 设置为适当遍历值数组，为每个待访问的子节点提供一个遍历值；如果不，让 traversalValues 保持为 NULL。注意，inner_consistent 函数负责在当前内存上下文中分配 nodeNumbers、levelAdds、distances、reconstructedValues 和 traversalValues 数组。然而，traversalValues 数组指向的任何输出遍历值都应该在 traversalMemoryContext 中分配。每个遍历值都必须是一个单独 alloc 的块。

如果叶子元组满足查询，则返回 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 是为父元组重建的值；在根级别它为 (Datum) 0，或者若 inner_consistent 函数没有在父级提供某个值时也是如此。 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是灵活的，它可能取决于用户指定的参数。