Amazon Redshift unterstützt UDFs ab Patch 198 nicht mehr die Erstellung von neuem Python. Das bestehende Python UDFs wird bis zum 30. Juni 2026 weiterhin funktionieren. Weitere Informationen finden Sie im [Blog-Posting](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/). 

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\$1 ToChildren
<a name="H3_ToChildren-function"></a>

H3\$1 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](spatial-terminology.md#spatial-terminology-h3).

## Syntax
<a name="H3_ToChildren-function-syntax"></a>

```
H3_ToChildren(index, resolution)
```

## Argumente
<a name="H3_ToChildren-function-arguments"></a>

 *index*   
Ein Wert vom Datentyp `BIGINT` oder`VARCHAR`, der den Index einer H3-Zelle darstellt, oder ein Ausdruck, der zu einem dieser Datentypen ausgewertet wird.

 *Auflösung*   
Ein Wert vom Datentyp `INTEGER` oder ein Ausdruck, der zu einem `INTEGER`-Typ ausgewertet wird. Der Wert steht für die Auflösung der untergeordneten Zelle. IDs Der Wert muss eine Ganzzahl zwischen der Auflösung des *Eingabeindex* und 15 (einschließlich) sein.

## Rückgabetyp
<a name="H3_ToChildren-function-return"></a>

`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
<a name="H3_ToChildren-function-examples"></a>

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;
```