返回有关索引实现的静态信息，包括前缀和节点标签数据类型的数据类型 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，如果操作符类能够重建最初提供的索引值。longValuesOK应仅在attType是变长且操作符类能够通过重复后缀分割长值时（请参阅第 65.3.4.1 节）设置为 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相同。leafDatum可以在树的较低级别更改，如果choose或picksplit方法更改了它。当插入搜索到达叶页时，leafDatum的当前值将存储在新创建的叶元组中。level是当前内部元组的级别，根级别从零开始。allTheSame如果当前内部元组被标记为包含多个等效节点（请参阅第 65.3.4.3 节），则为 true。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函数负责分配nodeLabels、mapTuplesToNodes和leafTupleDatums数组的内存。

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

仅在config函数将longValuesOK设置为 true 且提供了大于页面的输入值的情况下，picksplit才能应用于单个叶元组。在这种情况下，操作的目的是剥离前缀并生成一个新的、更短的叶数据值。该调用将重复，直到生成足够短以适应页面的叶数据值。有关更多信息，请参阅第 65.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；在这种情况下，所有节点都具有相同的标签（如果有），因此它们要么全部匹配查询，要么都不匹配查询（请参阅第 65.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函数负责在当前内存上下文中分配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中键的表示是灵活的，它可能取决于用户指定的参数。