Amazon Redshift ne prendra plus en charge la création de nouveaux UDFs Python à partir du patch 198. Les fonctions Python définies par l’utilisateur existantes continueront de fonctionner normalement 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.

# Fragmentation de données semi-structurées en colonnes SUPER avec des vues matérialisées
<a name="r_shred_super"></a>

Avec Amazon Redshift, vous pouvez améliorer les performances des requêtes en fragmentant les données dans des colonnes SUPER à l’aide de vues matérialisées. La fragmentation fait référence au processus qui consiste à décomposer des types de données complexes tels que des données semi-structurées JSON ou XML en colonnes plus petites et plus plates. Les colonnes SUPER sont une forme spécialisée de stockage en colonnes optimisée pour analyser rapidement les données fragmentées. 

Les sections suivantes décrivent les étapes et les considérations relatives à la fragmentation de données dans des colonnes SUPER à l’aide de vues matérialisées dans Amazon Redshift.

L’exemple suivant montre une définition de vue matérialisée qui fragmente les données imbriquées, les colonnes résultantes étant toujours du type de données SUPER.

```
SELECT c.c_name, o.o_orderstatus
FROM customer_orders_lineitem c, c.c_orders o;
```

L’exemple suivant illustre une définition de vue matérialisée qui crée des colonnes scalaires Amazon Redshift conventionnelles à partir des données fragmentées.

```
SELECT c.c_name, c.c_orders[0].o_totalprice
FROM customer_orders_lineitem c;
```

Vous pouvez créer une vue matérialisée unique super\_mv pour accélérer les deux requêtes.

Pour répondre à la première requête, vous devez matérialiser l’attribut o\_orderstatus. Vous pouvez omettre l’attribut c\_name car il n’implique pas la navigation imbriquée ni la désimbrication. Vous devez également inclure dans la vue matérialisée l’attribut c\_custkey de customer\_orders\_lineitem pour pouvoir joindre la table de base à la vue matérialisée.

Pour répondre à la deuxième requête, vous devez également matérialiser l’attribut o\_totalprice et l’index de tableau o\_idx de c\_orders. Ainsi, vous pouvez accéder à l’index 0 de c\_orders.

```
CREATE MATERIALIZED VIEW super_mv distkey(c_custkey) sortkey(c_custkey) AS (
  SELECT c_custkey, o.o_orderstatus, o.o_totalprice, o_idx
  FROM customer_orders_lineitem c, c.c_orders o AT o_idx
);
```

Les attributs o\_orderstatus et o\_totalprice de la vue matérialisée super\_mv sont SUPER.

La vue matérialisée super\_mv sera actualisée de manière incrémentielle lors des modifications apportées à la table de base customer\_orders\_lineitem.

```
REFRESH MATERIALIZED VIEW super_mv;
INFO: Materialized view super_mv was incrementally updated successfully.
```

Pour réécrire la première requête PartiQL en tant que requête SQL standard, joignez customer\_orders\_lineitem avec super\_mv comme suit.

```
SELECT c.c_name, v.o_orderstatus
FROM customer_orders_lineitem c 
JOIN super_mv v ON c.c_custkey = v.c_custkey;
```

De la même manière, vous pouvez réécrire la deuxième requête PartiQL. L’exemple suivant utilise un filtre sur o\_idx = 0.

```
SELECT c.c_name, v.o_totalprice
FROM customer_orders_lineitem c 
JOIN super_mv v ON c.c_custkey = v.c_custkey
WHERE v.o_idx = 0;
```

Dans l’instruction CREATE MATERIALISED VIEW, spécifiez c\_custkey comme clé de distribution et clé de tri pour super\_mv. Amazon Redshift effectue une fusion efficace, en supposant que c\_custkey est également la clé de distribution et la clé de tri de customer\_orders\_lineitem. Si ce n’est pas le cas, vous pouvez spécifier c\_custkey comme clé de tri et clé de distribution de customer\_orders\_lineitem comme suit.

```
ALTER TABLE customer_orders_lineitem
ALTER DISTKEY c_custkey, ALTER SORTKEY (c_custkey);
```

Utilisez l’instruction EXPLAIN pour vérifier qu’Amazon Redshift effectue une fusion sur les requêtes réécrites.

```
EXPLAIN
      SELECT c.c_name, v.o_orderstatus
      FROM customer_orders_lineitem c JOIN super_mv v ON c.c_custkey = v.c_custkey;
      
      QUERY PLAN                                              
      ------------------------------------------------------------------------------------------------------
      XN Merge Join DS_DIST_NONE  (cost=0.00..34701.82 rows=1470776 width=27)
      Merge Cond: ("outer".c_custkey = "inner".c_custkey)
      ->  XN Seq Scan on mv_tbl__super_mv__0 derived_table2  (cost=0.00..14999.86 rows=1499986 width=13)
      ->  XN Seq Scan on customer_orders_lineitem c  (cost=0.00..999.96 rows=99996 width=30)
      (4 rows)
```