Amazon Redshift wird UDFs ab dem 1. November 2025 die Erstellung von neuem Python nicht mehr unterstützen. Wenn Sie Python verwenden möchten UDFs, erstellen Sie das UDFs vor diesem Datum liegende. Bestehendes Python UDFs wird weiterhin wie gewohnt funktionieren. Weitere Informationen finden Sie im Blog-Posting.

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

H3_ ToChildren

H3_ ToChildren gibt eine Liste von untergeordneten H3-Zellen IDs mit einer angegebenen Auflösung für einen bestimmten H3-Index zurück. Weitere Informationen zur H3-Indizierung finden Sie in H3.

Syntax

H3_ToChildren(index, resolution)

Argumente

Rückgabetyp

SUPER— steht für eine Liste von H3-Zellen IDs.

Wenn entweder der Index oder die Auflösung NULL ist, wird NULL zurückgegeben.

Wenn index nicht gültig ist, wird ein Fehler zurückgegeben.

Wenn die Auflösung nicht zwischen der Auflösung von Index und 15 (einschließlich) liegt, wird ein Fehler zurückgegeben.

Wenn die Ausgabegröße die maximale SUPER-Größenbeschränkung überschreitet, wird ein Fehler zurückgegeben.

Beispiele

Das folgende SQL gibt einen VARCHAR ein, der den Index einer H3-Zelle darstellt, und einen INTEGER-Wert, der die gewünschte Auflösung aller untergeordneten Zellen darstellt, und gibt ein SUPER-Array zurück, das die untergeordneten Elemente mit Auflösung 6 enthält.

SELECT H3_ToChildren('85283473fffffff', 6);

 h3_tochildren                                                
--------------------------------------------------------------------------------------------------------------------------------------
 [604189641121202175,604189641255419903,604189641389637631,604189641523855359,604189641658073087,604189641792290815,604189641926508543]

Das folgende SQL gibt einen BIGINT ein, der den Index einer H3-Zelle darstellt, und einen INTEGER-Wert, der die gewünschte Auflösung aller untergeordneten Zellen darstellt, und gibt ein SUPER-Array zurück, das die untergeordneten Elemente mit Auflösung 6 enthält.

SELECT H3_ToChildren(599686042433355775, 6);

 h3_tochildren                                              
--------------------------------------------------------------------------------------------------------------------------------------
 [604189641121202175,604189641255419903,604189641389637631,604189641523855359,604189641658073087,604189641792290815,604189641926508543]

Hinweis: Ein Unterschied von 7 oder weniger zwischen Auflösung und Indexauflösung ist unbedenklich.

Das folgende Beispiel zeigt eine Problemumgehung für Abfragen, die die SUPER-Größenbeschränkung überschreiten. Wenn der Auflösungsunterschied zwischen dem Eingabe-H3-Index und der gewünschten untergeordneten Auflösung zu groß ist (größer als 7). Dieses Verfahren löst das Problem, indem untergeordnete Elemente schrittweise in kleineren Schritten erweitert werden (maximal 5 Auflösungsstufen gleichzeitig) und die Endergebnisse in einer vom Benutzer erstellten Tabelle gespeichert werden.

CREATE OR REPLACE PROCEDURE generate_h3_children()
LANGUAGE plpgsql
AS $$
BEGIN
    -- Drop and create h3_children table that will contain the results
    DROP TABLE IF EXISTS h3_children;
    CREATE TABLE h3_children (
        h3_index BIGINT,
        child_res INTEGER,
        children SUPER
    );

    -- Create temporary table for steps
    DROP TABLE IF EXISTS h3_steps;
    CREATE TABLE h3_steps (
        h3_index BIGINT,
        current_res INTEGER,
        target_res INTEGER,
        h3_array SUPER
    );

    -- Initial insert into h3_steps
    INSERT INTO h3_steps
    SELECT h3_index, H3_Resolution(h3_index), child_res, ARRAY(h3_index)
    FROM h3_indexes; -- Insert from your table with h3_index and child_res as columns

    -- Loop until we reach target resolution
    -- We expect at most 3 iterations considering that we can start at resolution
    -- 0 and target/child resolution equal to 15 (0 -> 5 -> 10 -> 15)
    WHILE EXISTS (
        SELECT 1
        FROM h3_steps h
        GROUP BY h3_index, target_res
        HAVING MAX(current_res) < target_res
    ) LOOP
        -- Populate the h3_steps table with the tables that need to
        -- reach closer to the target res
        INSERT INTO h3_steps
        SELECT
            h.h3_index,
            LEAST(h.current_res + 5, h.target_res), -- Do not exceed target res
            h.target_res,
            -- Take the children of the child cell at resolution current_res of the
            -- h3_index
            H3_ToChildren(c.child::BIGINT, LEAST(h.current_res + 5, h.target_res))
        FROM h3_steps h, UNNEST(h.h3_array) AS c(child)
        WHERE h.current_res < h.target_res
        AND h.current_res = (SELECT MAX(current_res)
                           FROM h3_steps
                           WHERE h3_index = h.h3_index
        );
    END LOOP;

    -- Store final results
    INSERT INTO h3_children
    SELECT h3_index AS h3_index, target_res AS child_res, h3_array AS children
    FROM h3_steps
    WHERE current_res = target_res;
END;
$$;

-- Create the source table for H3_ToChildren queries
CREATE TABLE h3_indexes (
    h3_index BIGINT,
    child_res INTEGER,
    PRIMARY KEY (h3_index, child_res)
);
INSERT INTO h3_indexes (h3_index, child_res)
VALUES (x'8001fffffffffff'::BIGINT, 11);

-- Execute the procedure
CALL generate_h3_children();

-- View results
SELECT * FROM h3_children;