Amazon Redshift ne prendra plus en charge la création de nouveaux Python à UDFs partir du patch 198. UDFs Le Python existant continuera de fonctionner jusqu'au 30 juin 2026. Pour plus d’informations, consultez le [ billet de blog ](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/). 

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# H3\$1 ToChildren
<a name="H3_ToChildren-function"></a>

H3\$1 ToChildren renvoie une liste de cellules H3 enfants IDs à une résolution spécifiée pour un index H3 donné. Pour en savoir plus sur l’indexation H3, consultez [H3](spatial-terminology.md#spatial-terminology-h3).

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

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

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

 *index*   
Une valeur de type de données `BIGINT` ou `VARCHAR` qui représente l'index d'une cellule H3, ou une expression qui correspond à l'un de ces types de données.

 *resolution*   
Valeur de type de données `INTEGER` ou expression qui est évaluée sur un type `INTEGER`. La valeur représente la résolution de la cellule enfant IDs. La valeur doit être un entier compris entre la résolution de l'*index* d'entrée et 15 inclus.

## Type de retour
<a name="H3_ToChildren-function-return"></a>

`SUPER`— représente une liste de cellules IDs H3.

Si *l'index* ou *la résolution* est NULL, NULL est renvoyé.

Si *index* n’est pas valide, une erreur est renvoyée.

Si *la résolution* n'est pas comprise entre la résolution de *l'index* et 15 inclus, une erreur est renvoyée.

Si la taille de sortie dépasse la limite maximale de taille SUPER, une erreur est renvoyée.

## Exemples
<a name="H3_ToChildren-function-examples"></a>

Le code SQL suivant saisit un VARCHAR qui représente l'index d'une cellule H3 et un INTEGER qui représente la résolution souhaitée pour tous les enfants, et renvoie un tableau SUPER contenant les enfants à la résolution 6.

```
SELECT H3_ToChildren('85283473fffffff', 6);
```

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

Le code SQL suivant saisit un BIGINT qui représente l'index d'une cellule H3 et un INTEGER qui représente la résolution souhaitée pour tous les enfants, et renvoie un tableau SUPER contenant les enfants à la résolution 6.

```
SELECT H3_ToChildren(599686042433355775, 6);
```

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

Remarque : Une différence de 7 ou moins entre la *résolution et la résolution* de *l'index* est sûre.

L'exemple suivant illustre une solution pour les requêtes qui dépassent la limite de taille SUPER. Lorsque la différence de résolution entre l'indice H3 d'entrée et la résolution enfant souhaitée est trop importante (supérieure à 7). Cette procédure résout le problème en élargissant progressivement les enfants par petites étapes (maximum 5 niveaux de résolution à la fois) et en stockant les résultats finaux dans un tableau créé par l'utilisateur.

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