Configurer un tri spécifique à la langue pour les résultats des requêtes Amazon Redshift à l'aide d'un UDF Python scalaire

Créée par Ethan Stark (AWS)

Environnement : Production

Technologies : Analytique

Services AWS : Amazon Redshift

Récapitulatif

Ce modèle fournit des étapes et un exemple de code pour utiliser une UDF (fonction définie par l'utilisateur) Python scalaire afin de configurer un tri linguistique insensible aux majuscules et minuscules pour les résultats des requêtes Amazon Redshift. Il est nécessaire d'utiliser un UDF Python scalaire car Amazon Redshift renvoie des résultats basés sur l'ordre binaire UTF-8 et ne prend pas en charge le tri spécifique à une langue. Un UDF Python est un code de traitement non SQL basé sur un programme Python 2.7 et exécuté dans un entrepôt de données. Vous pouvez exécuter du code UDF Python avec une instruction SQL dans une seule requête. Pour plus d'informations, consultez le billet de blog Amazon Redshift AWS Big Data consacré à l'introduction aux UDF en Python.

Les données d'échantillon de ce modèle sont basées sur l'alphabet turc à des fins de démonstration. Le scalaire Python UDF utilisé dans ce modèle est conçu pour que les résultats de requête par défaut d'Amazon Redshift soient conformes à l'ordre linguistique des caractères en turc. Pour plus d'informations, voir l'exemple de langue turque dans la section Informations supplémentaires de ce modèle. Vous pouvez modifier l'UDF Python scalaire dans ce modèle pour d'autres langages.

Conditions préalables et limitations

Prérequis

• Cluster Amazon Redshift avec base de données, schéma et tables

• Utilisateur Amazon Redshift disposant des autorisations CREATE TABLE et CREATE FUNCTION

• Python 2.7 ou version ultérieure

Limites

Le tri linguistique utilisé par les requêtes dans ce modèle ne fait pas la distinction majuscules/minuscules.

Architecture

Pile technologique

• Amazon Redshift

• UDF en Python

Outils

Services AWS

• Amazon Redshift est un service d'entrepôt de données géré à l'échelle du pétaoctet dans le cloud AWS. Amazon Redshift est intégré à votre lac de données, ce qui vous permet d'utiliser vos données pour acquérir de nouvelles informations pour votre entreprise et vos clients.

Autres outils

• Les fonctions définies par l'utilisateur en Python (UDFs) sont des fonctions que vous pouvez écrire en Python puis appeler dans des instructions SQL.

Épopées

Développez du code pour trier les résultats des requêtes par ordre linguistique

Tâche	Description	Compétences requises
Créez un tableau pour vos exemples de données.	Pour créer une table dans Amazon Redshift et y insérer vos exemples de données, utilisez les instructions SQL suivantes : CREATE TABLE my_table (first_name varchar(30)); INSERT INTO my_table (first_name) VALUES ('ali'), ('Ali'), ('ırmak'), ('IRMAK'), ('irem'), ('İREM'), ('oğuz'), ('OĞUZ'), ('ömer'), ('ÖMER'), ('sedat'), ('SEDAT'), ('şule'), Remarque : Les prénoms figurant dans les exemples de données incluent des caractères spéciaux de l'alphabet turc. Pour plus d'informations sur les considérations relatives à la langue turque pour cet exemple, voir l'exemple de langue turque dans la section Informations supplémentaires de ce modèle.	Ingénieur de données
Vérifiez le tri par défaut des échantillons de données.	Pour voir le tri par défaut de vos exemples de données dans Amazon Redshift, exécutez la requête suivante : SELECT first_name FROM my_table ORDER BY first_name; La requête renvoie la liste des prénoms de la table que vous avez créée précédemment : first_name --------------- Ali IRMAK OĞUZ SEDAT ali irem oğuz sedat ÖMER ömer İREM ırmak ŞULE şule Les résultats de la requête ne sont pas dans le bon ordre car l'ordre binaire UTF-8 par défaut ne correspond pas à l'ordre linguistique des caractères spéciaux turcs.	Ingénieur de données
Créez un UDF Python scalaire.	Pour créer un UDF Python scalaire, utilisez le code SQL suivant :  CREATE OR REPLACE FUNCTION collate_sort (value varchar) RETURNS varchar IMMUTABLE AS $$ def sort_str(val): import string dictionary = { 'I': 'ı', 'ı': 'h~', 'İ': 'i', 'Ş': 's~', 'ş': 's~', 'Ğ': 'g~', 'ğ': 'g~', 'Ü': 'u~', 'ü': 'u~', 'Ö': 'o~', 'ö': 'o~', 'Ç': 'c~', 'ç': 'c~' } for key, value in dictionary.items(): val = val.replace(key, value) return val.lower() return sort_str(value) $$ LANGUAGE plpythonu;	Ingénieur de données
Interrogez les exemples de données.	Pour interroger les exemples de données à l'aide de l'UDF Python, exécutez la requête SQL suivante : SELECT first_name FROM my_table ORDER BY collate_order(first_name); La requête renvoie désormais les exemples de données dans l'ordre linguistique turc : first_name --------------- ali Ali ırmak IRMAK irem İREM oğuz OĞUZ ömer Ömer sedat SEDAT şule ŞULE	Ingénieur de données

Ressources connexes

• Clause ORDER BY (documentation Amazon Redshift)

• Création d'un UDF Python scalaire (documentation Amazon Redshift)

Informations supplémentaires

Exemple de langue turque

Amazon Redshift renvoie les résultats des requêtes sur la base d'un ordre de tri binaire UTF-8, et non d'un ordre de tri spécifique à une langue. Cela signifie que si vous interrogez une table Amazon Redshift contenant des caractères turcs, les résultats de la requête ne sont pas triés selon l'ordre linguistique de la langue turque. La langue turque contient six caractères spéciaux (ç, ı, ğ, ö, ş et ü) qui n'apparaissent pas dans l'alphabet latin. Ces caractères spéciaux sont placés à la fin d'un ensemble de résultats triés en fonction de l'ordre binaire UTF-8, comme le montre le tableau suivant.

Ordre binaire UTF-8	Ordre linguistique turc
a	a
b	b
c	c
d	mois (*)
e	d
f	e
g	f
h	g
i	ğ (*)
j	h
k	Oui (*)
l	i
m	j
n	k
o	l
p	m
r	n
s	o
t	île (*)
u	p
v	r
y	s
z	Oui (*)
mois (*)	t
ğ (*)	u
Oui (*)	ü (*)
île (*)	v
Oui (*)	y
ü (*)	z

Remarque : L'astérisque (*) indique un caractère spécial dans la langue turque.

Comme l'illustre le tableau ci-dessus, le caractère spécial ç se situe entre c et d dans l'ordre linguistique turc, mais apparaît après z dans l'ordre binaire UTF-8. Dans ce modèle, le scalaire Python UDF utilise le dictionnaire de remplacement de caractères suivant pour remplacer les caractères spéciaux turcs par des caractères équivalents en latin correspondants.

Caractère spécial turc	Caractère équivalent en latin
ç	c~
ı	h~
ğ	g~
ö	o~
ş	s~
ü	u~

Remarque : Un tilde (~) est ajouté à la fin des caractères latins pour remplacer les caractères spéciaux turcs correspondants.

Modifier une fonction UDF Python scalaire

Pour modifier la fonction UDF scalaire de Python à partir de ce modèle afin qu'elle accepte un paramètre de localisation et prenne en charge un dictionnaire de transactions multiples, utilisez le code SQL suivant :

CREATE OR REPLACE FUNCTION collate_sort (value varchar, locale varchar) 
RETURNS varchar 
IMMUTABLE 
AS 
$$    
    def sort_str(val):
       import string
       # Turkish Dictionary
       if locale == 'tr-TR':
            dictionary = {
               'I': 'ı', 
               'ı': 'h~', 
               'İ': 'i', 
               'Ş': 's~', 
               'ş': 's~', 
               'Ğ': 'g~', 
               'ğ': 'g~', 
               'Ü': 'u~', 
               'ü': 'u~', 
               'Ö': 'o~', 
               'ö': 'o~', 
               'Ç': 'c~', 
               'ç': 'c~'
        }
        # German Dictionary
        if locale == 'de-DE':
            dictionary = {
               ....
               ....
        }
        
        for key, value in dictionary.items():
            val = val.replace(key, value)
        
        return val.lower()
 
    return sort_str(value)
    
$$ LANGUAGE plpythonu;

L'exemple de code suivant montre comment interroger l'UDF Python modifié :

SELECT first_name FROM my_table ORDER BY collate_order(first_name, 'tr-TR');