傳回有關索引實作的靜態資訊，包括前綴和節點標籤資料類型的資料類型 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 應用於 datum 的結果 (如果提供了方法 compress 的話)，否則與 datum 的值相同。leafDatum 可以在樹的較低層級中改變，如果 choose 或 picksplit 方法改變了它。當插入搜尋到達葉節點頁面時，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 的陣列，其中包含它們的標籤，如果不需要節點標籤，則設定為 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 的 nodeLabels、mapTuplesToNodes 和 leafTupleDatums 陣列。

如果提供多個葉節點元組，則預期 picksplit 函數將它們分類到多個節點中；否則無法跨多個頁面分割葉節點元組，這是此操作的最終目的。因此，如果 picksplit 函數最終將所有葉節點元組放置在同一個節點中，則核心 SP-GiST 程式碼將覆蓋該決定並產生一個內部元組，其中葉節點元組被隨機分配給多個具有相同標籤的節點。這樣的元組被標記為 allTheSame 以表示發生了這種情況。choose 和 inner_consistent 函數必須適當地處理這樣的內部元組。請參閱第 64.3.4.3 節以獲取更多資訊。

只有在 config 函數設定 longValuesOK 為 true，且提供了大於一頁的輸入值時，picksplit 才能應用於單一葉節點元組。在這種情況下，操作的重點是剝離前綴，並產生一個新的、更短的葉節點資料值。這個呼叫會重複執行，直到產生一個短到足以容納在一頁上的葉節點資料。

傳回在樹狀結構搜尋期間要追蹤的節點（分支）集合。

核心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 方法僅適用於要儲存的數值。 consistent 方法接收未經修改的查詢 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中很靈活，因此它可能取決於使用者指定的參數。