Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Imposta l'ordinamento specifico della lingua per i risultati delle query di Amazon Redshift utilizzando un UDF scalare in Python
<a name="set-up-language-specific-sorting-for-amazon-redshift-query-results-using-a-scalar-python-udf"></a>

*Ethan Stark, Amazon Web Services*

## Riepilogo
<a name="set-up-language-specific-sorting-for-amazon-redshift-query-results-using-a-scalar-python-udf-summary"></a>

Questo modello fornisce passaggi e codice di esempio per l'utilizzo di un UDF scalare in Python (funzione definita dall'utente) per configurare l'ordinamento linguistico senza distinzione tra maiuscole e minuscole per i risultati delle query di Amazon Redshift. È necessario utilizzare un UDF Python scalare perché Amazon Redshift restituisce risultati basati sull'ordinamento binario UTF-8 e non supporta l'ordinamento specifico della lingua. Un UDF Python è un codice di elaborazione non SQL basato su un programma Python ed eseguito in un data warehouse. È possibile eseguire il codice UDF Python con un'istruzione SQL in una singola query. Per ulteriori informazioni, consulta il post del [blog Introduzione a Python UDFs in Amazon](https://aws.amazon.com/blogs/big-data/introduction-to-python-udfs-in-amazon-redshift/) AWS Redshift Big Data.

I dati di esempio di questo modello si basano sull'alfabeto turco a scopo dimostrativo. L'UDF scalare Python in questo modello è stato creato per rendere i risultati delle query predefiniti di Amazon Redshift conformi all'ordinamento linguistico dei caratteri in lingua turca. *Per ulteriori informazioni, consulta l'*esempio della lingua turca* nella sezione Informazioni aggiuntive di questo modello.* È possibile modificare l'UDF scalare di Python in questo modello per altri linguaggi.

## Prerequisiti e limitazioni
<a name="set-up-language-specific-sorting-for-amazon-redshift-query-results-using-a-scalar-python-udf-prereqs"></a>

**Prerequisiti**
+ [Cluster Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-clusters.html) con database, schema e tabelle
+ [Utente Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/dg/r_Users.html) con `CREATE TABLE` e autorizzazioni `CREATE FUNCTION`
+ [Python 2.7](https://www.python.org/download/releases/2.7/) o successivo

**Limitazioni**

L'ordinamento linguistico utilizzato dalle query in questo modello non fa distinzione tra maiuscole e minuscole.

## Tools (Strumenti)
<a name="set-up-language-specific-sorting-for-amazon-redshift-query-results-using-a-scalar-python-udf-tools"></a>

**Servizi AWS**
+ [Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/gsg/getting-started.html) è un servizio di data warehouse gestito su scala petabyte disponibile in. Cloud AWS Amazon Redshift è integrato con il tuo data lake, il che ti consente di utilizzare i tuoi dati per acquisire nuove informazioni per la tua azienda e i tuoi clienti.

**Altri strumenti**
+ Le [funzioni definite dall'utente in Python (UDFs)](https://docs.snowflake.com/en/developer-guide/udf/python/udf-python-introduction.html) sono funzioni che è possibile scrivere in Python e quindi richiamare istruzioni SQL.

## Epiche
<a name="set-up-language-specific-sorting-for-amazon-redshift-query-results-using-a-scalar-python-udf-epics"></a>

### Sviluppa codice per ordinare i risultati delle query in ordine linguistico
<a name="develop-code-to-sort-query-results-in-linguistic-order"></a>


| Operazione | Description | Competenze richieste | 
| --- | --- | --- | 
| Crea una tabella per i tuoi dati di esempio. | Per creare una tabella in Amazon Redshift e inserire i dati di esempio nella tabella, utilizza le seguenti istruzioni SQL:<pre>CREATE TABLE my_table (first_name varchar(30));<br /><br />INSERT INTO my_table (first_name)<br />VALUES<br />    ('ali'),<br />    ('Ali'),<br />    ('ırmak'),<br />    ('IRMAK'),<br />    ('irem'),<br />    ('İREM'),<br />    ('oğuz'),<br />    ('OĞUZ'),<br />    ('ömer'),<br />    ('ÖMER'),<br />    ('sedat'),<br />    ('SEDAT'),<br />    ('şule'),</pre>I primi nomi nei dati di esempio includono caratteri speciali dell'alfabeto turco. Per ulteriori informazioni sulle considerazioni relative alla lingua turca relative a questo esempio, consultate *Esempio di lingua turca* nella sezione *Informazioni aggiuntive* di questo modello. | Ingegnere dei dati | 
| Controlla l'ordinamento predefinito dei dati di esempio. | Per visualizzare l'ordinamento predefinito dei dati di esempio in Amazon Redshift, esegui la seguente query:<pre>SELECT first_name FROM my_table ORDER BY first_name;</pre><br />La query restituisce l'elenco dei nomi dalla tabella creata in precedenza:<pre>first_name<br />---------------<br />Ali<br />IRMAK<br />OĞUZ<br />SEDAT<br />ali<br />irem<br />oğuz<br />sedat<br />ÖMER<br />ömer<br />İREM<br />ırmak<br />ŞULE<br />şule</pre><br />I risultati della query non sono nell'ordine corretto perché l'ordinamento binario UTF-8 predefinito non supporta l'ordinamento linguistico dei caratteri speciali turchi. | Ingegnere dei dati | 
| Crea una UDF Python scalare. | Per creare una UDF Python scalare, usa il seguente codice SQL: <pre>CREATE OR REPLACE FUNCTION collate_sort (value varchar) <br />RETURNS varchar <br />IMMUTABLE <br />AS <br />$$    <br />    def sort_str(val):<br />        import string<br />        <br />        dictionary = {<br />            'I': 'ı', <br />            'ı': 'h~', <br />            'İ': 'i', <br />            'Ş': 's~', <br />            'ş': 's~', <br />            'Ğ': 'g~', <br />            'ğ': 'g~', <br />            'Ü': 'u~', <br />            'ü': 'u~', <br />            'Ö': 'o~', <br />            'ö': 'o~', <br />            'Ç': 'c~', <br />            'ç': 'c~'<br />        }<br />        <br />        for key, value in dictionary.items():<br />            val = val.replace(key, value)<br />        <br />        return val.lower()<br /> <br />    return sort_str(value)<br />    <br />$$ LANGUAGE plpythonu;</pre> | Ingegnere dei dati | 
| Interroga i dati di esempio. | Per interrogare i dati di esempio utilizzando Python UDF, esegui la seguente query SQL:<pre>SELECT first_name FROM my_table ORDER BY collate_sort(first_name);</pre><br />La query ora restituisce i dati di esempio in ordine linguistico turco:<pre>first_name<br />---------------<br />ali<br />Ali<br />ırmak<br />IRMAK<br />irem<br />İREM<br />oğuz<br />OĞUZ<br />ömer<br />Ömer<br />sedat<br />SEDAT<br />şule<br />ŞULE</pre> | Ingegnere dei dati | 

## Risorse correlate
<a name="set-up-language-specific-sorting-for-amazon-redshift-query-results-using-a-scalar-python-udf-resources"></a>
+ [Clausola ORDER BY](https://docs.aws.amazon.com/redshift/latest/dg/r_ORDER_BY_clause.html) (documentazione Amazon Redshift)
+ [Creazione di una UDF scalare in Python](https://docs.aws.amazon.com/redshift/latest/dg/udf-creating-a-scalar-udf.html) (documentazione Amazon Redshift)

## Informazioni aggiuntive
<a name="set-up-language-specific-sorting-for-amazon-redshift-query-results-using-a-scalar-python-udf-additional"></a>

**Esempio di lingua turca**

Amazon Redshift restituisce i risultati delle query in base all'ordinamento binario UTF-8, non all'ordinamento specifico della lingua. Ciò significa che se esegui una query su una tabella Amazon Redshift contenente caratteri turchi, i risultati della query non vengono ordinati in base all'ordinamento linguistico della lingua turca. La lingua turca contiene sei caratteri speciali (ç, ı, ğ, ö, ş e ü) che non compaiono nell'alfabeto latino. Questi caratteri speciali vengono posizionati alla fine di un set di risultati ordinato in base all'ordinamento binario UTF-8, come illustrato nella tabella seguente.


| 
| 
| Ordinamento binario UTF-8 | Ordinamento linguistico turco | 
| --- |--- |
| a | a | 
| b | b | 
| c | c | 
| d | **ç (\*)** | 
| e | d | 
| f | e | 
| g | f | 
| h | g | 
| i | **ğ (\*)** | 
| j | h | 
| k | **ı (\*)** | 
| l | i | 
| m | j | 
| n | k | 
| o | l | 
| p | m | 
| r | n | 
| s | o | 
| t | **ö (\*)** | 
| u | p | 
| v | r | 
| y | s | 
| z | **s (\*)** | 
| **c (\*)** | t | 
| **ğ (\*)** | u | 
| **ı (\*)** | **ü (\*)** | 
| **ö (\*)** | v | 
| **s (\*)** | y | 
| **ü (\*)** | z | 

**Nota**  
L'asterisco (\*) indica un carattere speciale nella lingua turca.

Come illustrato nella tabella precedente, il carattere speciale **ç** è compreso tra **c** e **d** nell'ordinamento linguistico turco, ma appare dopo **z** nell'ordinamento binario UTF-8. L'UDF scalare Python in questo modello utilizza il seguente dizionario di sostituzione dei caratteri per sostituire i caratteri speciali turchi con i corrispondenti caratteri equivalenti al latino.


| 
| 
| Carattere speciale turco | Carattere equivalente al latino | 
| --- |--- |
| ç | c\~ | 
| ı | h \~ | 
| ğ | g \~ | 
| ö | o\~ | 
| ş | s\~ | 
| ü | u\~ | 

**Nota**  
Un carattere tilde (\~) viene aggiunto alla fine dei caratteri latini che sostituiscono i corrispondenti caratteri speciali turchi.

**Modifica una funzione UDF Python scalare**

Per modificare la funzione UDF scalare di Python da questo modello in modo che la funzione accetti un parametro locate e supporti un dizionario di transazioni multiple, usa il seguente codice SQL:

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

Il codice di esempio seguente mostra come interrogare l'UDF Python modificato:

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