Amazon Redshift non supporterà più la creazione di nuovi Python UDFs a partire dalla Patch 198. Python esistente UDFs continuerà a funzionare fino al 30 giugno 2026. Per ulteriori informazioni, consulta il [post del blog](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/). 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à. # CREATE DATABASE Crea un nuovo database. Per creare un database, devi essere un utente con privilegi avanzati o disporre del privilegio CREATEDB. Per creare un database associato a un’integrazione Zero-ETL, devi essere un utente con privilegi avanzati o disporre di entrambi i privilegi CREATEDB e CREATEUSER. Non è possibile eseguire CREATE DATABASE all'interno di un blocco di transazione (BEGIN ... END). Per ulteriori informazioni sulle transazioni, consultare [Livelli di isolamento in Amazon Redshift](c_serial_isolation.md). ## Sintassi ``` CREATE DATABASE database_name [ { [ FROM INTEGRATION ''[ DATABASE '' ] [ SET ] [ ACCEPTINVCHARS [=] { TRUE | FALSE }] [ QUERY_ALL_STATES [=] { TRUE | FALSE }] [ REFRESH_INTERVAL ] [ TRUNCATECOLUMNS [=] { TRUE | FALSE } ] [ HISTORY_MODE [=] {TRUE | FALSE} ] ] [ WITH ] [ OWNER [=] db_owner ] [ CONNECTION LIMIT { limit | UNLIMITED } ] [ COLLATE { CASE_SENSITIVE | CS | CASE_INSENSITIVE | CI } ] [ ISOLATION LEVEL { SNAPSHOT | SERIALIZABLE } ] } | { FROM { { ARN '' } { WITH DATA CATALOG SCHEMA '' | WITH NO DATA CATALOG SCHEMA } } } | { IAM_ROLE {default | 'SESSION' | 'arn:aws:iam:::role/' } } | { [ WITH PERMISSIONS ] FROM DATASHARE datashare_name OF [ ACCOUNT account_id ] NAMESPACE namespace_guid } ] ``` ## Parameters *database\$1name* Nome del nuovo database. Per ulteriori informazioni sui nomi validi, consultare [Nomi e identificatori](r_names.md). FROM INTEGRATION '' [ DATABASE '' ] Specifica se creare il database utilizzando un identificatore di integrazione Zero-ETL. Puoi recuperare il formato `integration_id` dalla vista di sistema SVV\$1INTEGRATION. Per le integrazioni Zero-ETL di Aurora PostgreSQL, devi inoltre specificare il nome `source_database`, che può essere recuperato anche da SVV\$1INTEGRATION. Per vedere un esempio, consulta [Crea database per ricevere i risultati delle integrazioni Zero-ETL](#r_CREATE_DATABASE-integration). Per ulteriori informazioni sulla creazione di database con integrazioni Zero-ETL, consulta [Creazione di database di destinazione in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.creating-db.html) nella *Guida alla gestione di Amazon Redshift*. SET Parola chiave facoltativa. ACCEPTINVCHARS [=] \$1 TRUE \$1 FALSE \$1 La clausola ACCEPTINVCHARS imposta se le tabelle di integrazione Zero-ETL continuano con l’importazione quando per il tipo di dati VARCHAR vengono rilevati caratteri non validi. Quando vengono rilevati caratteri non validi, il carattere non valido viene sostituito con un carattere `?` predefinito. QUERY\$1ALL\$1STATES [=] \$1 TRUE \$1 FALSE \$1 La clausola QUERY\$1ALL\$1STATES imposta se è possibile eseguire query sulle tabelle di integrazione Zero-ETL in tutti gli stati (`Synced`, `Failed`, `ResyncRequired` e `ResyncInitiated`). Per impostazione predefinita puoi eseguire query su una tabella di integrazione Zero-ETL solo nello stato `Synced`. REFRESH\$1INTERVAL La clausola REFRESH\$1INTERVAL imposta l’intervallo di tempo approssimativo, in secondi, per aggiornare i dati dall’origine zero-ETL al database di destinazione. Il valore può essere impostato su un numero compreso tra 0 e 432.000 secondi (5 giorni) per le integrazioni Zero-ETL il cui tipo di origine è Aurora MySQL, Aurora PostgreSQL o RDS per MySQL. Per le integrazioni Zero-ETL di Amazon DynamoDB, il valore può essere impostato su un numero compreso tra 900 e 432.000 secondi (15 minuti – 5 giorni). L’impostazione predefinita di `interval` è zero (0) secondi per le integrazioni Zero-ETL il cui tipo di origine è Aurora MySQL, Aurora PostgreSQL o RDS per MySQL. Per le integrazioni Zero-ETL di Amazon DynamoDB, l’impostazione predefinita di `interval` è 900 secondi (15 minuti). TRUNCATECOLUMNS [=] \$1TRUE \$1 FALSE\$1 La clausola TRUNCATECOLUMNS imposta se le tabelle di integrazione Zero-ETL continuano con l’importazione quando i valori per gli attributi della colonna VARCHAR o della colonna SUPER superano il limite. Quando è `TRUE`, i valori vengono troncati per adattarsi alla colonna e i valori degli attributi JSON in overflow vengono troncati per adattarsi alla colonna SUPER. HISTORY\$1MODE [=] \$1TRUE \$1 FALSE\$1 Una clausola che specifica se Amazon Redshift imposterà la modalità cronologia per tutte le nuove tabelle nel database specificato. Questa opzione è applicabile solo ai database creati per l’integrazione Zero-ETL. La clausola HISTORY\$1MODE può essere impostata su `TRUE` o `FALSE`. Il valore predefinito è `FALSE`. Per informazioni su HISTORY\$1MODE, consulta [Modalità cronologia](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-history-mode.html) nella *Guida alla gestione di Amazon Redshift*. WITH Parola chiave facoltativa. OWNER [=] db\$1owner Specifica il nome utente del proprietario del database. CONNECTION LIMIT \$1 *limit* \$1 UNLIMITED \$1 Numero massimo di connessioni di database che gli utenti possono aprire contemporaneamente. Il limite non viene applicato per gli utente con privilegi avanzati. Utilizza la parola chiave UNLIMITED per consentire il numero massimo di connessioni simultanee. È possibile che venga applicato anche un limite al numero di connessioni per ciascun utente. Per ulteriori informazioni, consultare [CREA UTENTE](r_CREATE_USER.md). Il valore predefinito è UNLIMITED. Per visualizzare le connessioni correnti, eseguire una query sulla vista di sistema [STV\$1SESSIONS](r_STV_SESSIONS.md). Se si applicano entrambi i limiti di connessione utente e database, deve essere disponibile uno slot di connessione inutilizzato che rientra in entrambi i limiti quando un utente tenta di connettersi. COLLATE \$1 CASE\$1SENSITIVE \$1 CS \$1 CASE\$1INSENSITIVE \$1 CI \$1 Una clausola che specifica se la ricerca o il confronto di stringhe fa distinzione tra maiuscole e minuscole o meno. L’impostazione predefinita fa distinzione tra maiuscole e minuscole. COLLATE non è supportato quando si crea un database da un’unità di condivisione dati. CASE\$1SENSITIVE e CS sono intercambiabili e producono gli stessi risultati. Allo stesso modo CASE\$1INSENSITIVE e CI sono intercambiabili e producono gli stessi risultati. ISOLATION LEVEL \$1 SNAPSHOT \$1 SERIALIZABLE \$1 Una clausola che specifica il livello di isolamento utilizzato quando vengono eseguite query su un database. Per ulteriori informazioni sui livello di isolamento, consulta [Livelli di isolamento in Amazon Redshift](c_serial_isolation.md). + Isolamento SNAPSHOT: fornisce un livello di isolamento con protezione contro i conflitti di aggiornamento ed eliminazione. Questa è l’impostazione predefinita per un database creato in un cluster con provisioning o un namespace serverless. + Isolamento SERIALIZABLE: fornisce la serializzabilità completa per le transazioni simultanee. FROM ARN '' L'ARN del AWS Glue database da utilizzare per creare il database. \$1 WITH DATA CATALOG SCHEMA '' \$1 WITH NO DATA CATALOG SCHEMA \$1 Questo parametro è applicabile solo se il comando CREATE DATABASE utilizza anche il parametro FROM ARN. Specifica se creare il database utilizzando uno schema per agevolare l'accesso agli oggetti da AWS Glue Data Catalog. IAM\$1ROLE \$1default \$1 'SESSION' \$1 'arn:aws:iam: :role/ '\$1 ** ** Questo parametro è applicabile solo se il comando CREATE DATABASE utilizza anche il parametro FROM ARN. Se specifichi un ruolo IAM associato al cluster quando esegui il comando CREATE DATABASE, Amazon Redshift utilizzerà le credenziali del ruolo quando esegui le query sul database. Specificare la parola chiave `default` significa utilizzare il ruolo IAM impostato come predefinito e associato al cluster. Utilizzare `'SESSION'` se ci si connette al cluster Amazon Redshift utilizzando un'identità federata e si accede alle tabelle dallo schema esterno creato con questo comando. Per ulteriori informazioni, consulta l'argomento relativo a [Utilizzo di un'identità federata per gestire l'accesso di Amazon Redshift alle risorse locali e alle tabelle esterne di Amazon Redshift Spectrum](https://docs.aws.amazon.com/redshift/latest/mgmt/authorization-fas-spectrum.html), che illustra come configurare l'identità federata. L'Amazon Resource Name (ARN) per un ruolo IAM utilizzato dal cluster per l'autenticazione e l'autorizzazione. Come minimo, il ruolo IAM deve disporre dell'autorizzazione per eseguire un'operazione LIST sul bucket Amazon S3 a cui accedere e un'operazione GET sugli oggetti Amazon S3 contenuti nel bucket. Per ulteriori informazioni sull'utilizzo di IAM\$1ROLE durante la creazione di un database utilizzando AWS Glue Data Catalog per le condivisioni di dati, consulta [Lavorare con le condivisioni di dati gestite da Lake Formation come consumatore](https://docs.aws.amazon.com/redshift/latest/dg/lake-formation-getting-started-consumer.html). Quanto segue mostra la sintassi per la stringa di parametro IAM\$1ROLE per un singolo ARN. ``` IAM_ROLE 'arn:aws:iam:::role/' ``` È possibile concatenare i ruoli in modo che il cluster possa presumere un altro ruolo IAM, possibilmente appartenente a un altro account. Puoi concatenare fino a 10 ruoli. Per ulteriori informazioni, consulta [Concatenazione di ruoli IAM per Amazon Redshift Spectrum](c-spectrum-iam-policies.md#c-spectrum-chaining-roles). Per collegare a questo ruolo IAM una policy di autorizzazioni IAM simile alla seguente. **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "AccessSecret", "Effect": "Allow", "Action": [ "secretsmanager:GetResourcePolicy", "secretsmanager:GetSecretValue", "secretsmanager:DescribeSecret", "secretsmanager:ListSecretVersionIds" ], "Resource": "arn:aws:secretsmanager:us-west-2:123456789012:secret:my-rds-secret-VNenFy" }, { "Sid": "VisualEditor1", "Effect": "Allow", "Action": [ "secretsmanager:GetRandomPassword", "secretsmanager:ListSecrets" ], "Resource": "*" } ] } ``` Per la procedura per creare un ruolo IAM da utilizzare con la query federata, consultare [Creazione di un segreto e di un ruolo IAM per l'utilizzo di query federate](federated-create-secret-iam-role.md). Non includere spazi nell'elenco dei ruoli concatenati. Quanto segue mostra la sintassi per concatenare tre ruoli. ``` IAM_ROLE 'arn:aws:iam:::role/,arn:aws:iam:::role/,arn:aws:iam:::role/' ``` ## Sintassi per l'uso di CREATE DATABASE con una unità di condivisione dati La sintassi seguente descrive il comando CREATE DATABASE utilizzato per creare database da un datashare per condividere dati all'interno dello stesso account. AWS ``` CREATE DATABASE database_name [ [ WITH PERMISSIONS ] FROM DATASHARE datashare_name OF [ ACCOUNT account_id ] NAMESPACE namespace_guid ``` La sintassi seguente descrive il comando CREATE DATABASE utilizzato per creare database da un datashare per la condivisione di dati tra account. AWS ``` CREATE DATABASE database_name [ [ WITH PERMISSIONS ] FROM DATASHARE datashare_name OF ACCOUNT account_id NAMESPACE namespace_guid ``` ### Parametri per l'uso di CREATE DATABASE con una unità di condivisione dati FROM DATASHARE Una parola chiave che indica dove si trova l'unità di condivisione dati. *datashare\$1name* Il nome dell'unità di condivisione dati in cui viene creato il database consumer. WITH PERMISSIONS Specifica che il database creato dall'unità di condivisione dati richiede autorizzazioni a livello di oggetto per accedere ai singoli oggetti del database. Senza questa clausola, gli utenti o i ruoli a cui è stata concessa l'autorizzazione USAGE sul database hanno automaticamente accesso a tutti gli oggetti del database. NAMESPACE *namespace\$1guid* Un valore che specifica lo spazio dei nomi del produttore a cui appartiene l'unità di condivisione dati. ACCOUNT *account\$1id* Un valore che specifica lo spazio dei nomi del produttore a cui appartiene l'unità di condivisione dati. ## Note di utilizzo per CREATE DATABASE per la condivisione di dati In qualità di superutente del database, quando utilizzi CREATE DATABASE per creare database da datashare all'interno dell' AWS account, specifica l'opzione NAMESPACE. L'opzione ACCOUNT è facoltativa. Quando si utilizza CREATE DATABASE per creare database da unità di condivisione dati tra account AWS , è necessario specificare le opzioni ACCOUNT e NAMESPACE dal producer. È possibile creare un solo database consumer per un'unità unità di condivisione dati in un cluster consumer. Non è possibile creare più database consumer che si riferiscono alla stessa unità di condivisione dati. ## CREA DATABASE da AWS Glue Data Catalog Per creare un database utilizzando un ARN di AWS Glue database, specifica l'ARN nel comando CREATE DATABASE. ``` CREATE DATABASE sampledb FROM ARN WITH NO DATA CATALOG SCHEMA; ``` Facoltativamente, puoi anche fornire un valore nel parametro IAM\$1ROLE. Per ulteriori informazioni sui parametri e sui valori accettati, consulta [Parametri](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_DATABASE.html#r_CREATE_DATABASE-parameters). Di seguito sono riportati esempi che dimostrano come creare un database da un ARN utilizzando un ruolo IAM. ``` CREATE DATABASE sampledb FROM ARN WITH NO DATA CATALOG SCHEMA IAM_ROLE ``` ``` CREATE DATABASE sampledb FROM ARN WITH NO DATA CATALOG SCHEMA IAM_ROLE default; ``` È inoltre possibile creare un database utilizzando uno SCHEMA DEL CATALOGO DATI. ``` CREATE DATABASE sampledb FROM ARN WITH DATA CATALOG SCHEMA IAM_ROLE default; ``` ## Crea database per ricevere i risultati delle integrazioni Zero-ETL Per creare un database utilizzando un’identità di integrazione Zero-ETL, specifica il valore `integration_id` nel comando CREATE DATABASE. ``` CREATE DATABASE destination_db_name FROM INTEGRATION 'integration_id'; ``` Ad esempio, recupera innanzitutto gli ID di integrazione da SVV\$1INTEGRATION. ``` SELECT integration_id FROM SVV_INTEGRATION; ``` Quindi utilizza uno degli ID di integrazione recuperati per creare il database che riceve le integrazioni Zero-ETL. ``` CREATE DATABASE sampledb FROM INTEGRATION 'a1b2c3d4-5678-90ab-cdef-EXAMPLE11111'; ``` Quando è necessario il database di origine delle integrazioni Zero-ETL, ad esempio, specifica: ``` CREATE DATABASE sampledb FROM INTEGRATION 'a1b2c3d4-5678-90ab-cdef-EXAMPLE11111' DATABASE sourcedb; ``` Puoi inoltre impostare un intervallo di aggiornamento per il database. Ad esempio, per impostare l’intervallo di aggiornamento su 7.200 secondi per i dati provenienti da una fonte di integrazione Zero-ETL: ``` CREATE DATABASE myacct_mysql FROM INTEGRATION 'a1b2c3d4-5678-90ab-cdef-EXAMPLE11111' SET REFRESH_INTERVAL 7200; ``` Esegui la query sulla vista del catalogo SVV\$1INTEGRATION per informazioni su un’integrazione Zero-ETL, ad esempio integration\$1id, target\$1database, source, refresh\$1interval e altro. ``` SELECT * FROM svv_integration; ``` L’esempio seguente crea un database a partire da un’integrazione con la modalità cronologia attiva. ``` CREATE DATABASE sample_integration_db FROM INTEGRATION 'a1b2c3d4-5678-90ab-cdef-EXAMPLE11111' SET HISTORY_MODE = true; ``` ## Limiti di CREATE DATABASE Amazon Redshift applica i seguenti limiti per i database: + Massimo 60 database definiti dall'utente per cluster. + Massimo 127 byte per un nome del database. + Il nome di un database non può essere una parola riservata. ## Confronto di database Il confronto è un insieme di regole che definisce il modo in cui il motore di database confronta e ordina i dati di tipo carattere in SQL. Il confronto senza distinzione tra maiuscole e minuscole è il tipo di confronto più utilizzato. Amazon Redshift utilizza il confronto senza distinzione tra maiuscole e minuscole per facilitare la migrazione da altri sistemi di data warehouse. Con il supporto nativo del confronto senza distinzione tra maiuscole e minuscole, Amazon Redshift continua a utilizzare importanti metodi di regolazione o ottimizzazione, come le chiavi di distribuzione, le chiavi di ordinamento o la scansione con intervallo limitato. La clausola COLLATE specifica il confronto di default per tutte le colonne CHAR e VARCHAR nel database. Se è specificato CASE\$1INSENSITIVE, tutte le colonne CHAR o VARCHAR utilizzano confronto senza distinzione tra maiuscole e minuscole Per informazioni sul confronto, consultare [Sequenze di regole di confronto](c_collation_sequences.md). I dati inseriti o importati nelle colonne senza distinzione tra maiuscole e minuscole manterranno il loro formato maiuscole/minuscole originale. Ma tutte le operazioni di stringa basate su confronto, inclusi l'ordinamento e il raggruppamento, non fanno distinzione tra maiuscole e minuscole. Anche le operazioni di corrispondenza dei modelli come predicati LIKE, SIMILAR TO e funzioni di espressione regolare non fanno distinzione tra maiuscole e minuscole. Le seguenti operazioni SQL supportano la semantica di confronto applicabile: + Operatori di confronto: =, <>, <, <=, >, >=. + Operatore LIKE + Clausola ORDER BY + Clausole GROUP BY + Funzioni di aggregazione che utilizzano il confronto di stringhe, come MIN e MAX e LISTAGG + Funzioni finestra, ad esempio clausole PARTITION BY e clausole ORDER BY + Funzioni scalari greatest() e least(), STRPOS(), REGEXP\$1COUNT(), REGEXP\$1REPLACE(), REGEXP\$1INSTR(), REGEXP\$1SUBSTR() + Clausola separata + UNION, INTERSECT ed EXCEPT + IN LIST Per le query esterne, incluse le query federate di Amazon Redshift Spectrum e Aurora PostgreSQL, il confronto della colonna VARCHAR o CHAR è uguale al confronto corrente a livello di database. Nell'esempio seguente viene eseguita una query su una tabella Amazon Redshift Spectrum: ``` SELECT ci_varchar FROM spectrum.test_collation WHERE ci_varchar = 'AMAZON'; ci_varchar ---------- amazon Amazon AMAZON AmaZon (4 rows) ``` Per informazioni su come creare le tabelle mediante il confronto di database, consultare [CREATE TABLE](r_CREATE_TABLE_NEW.md). Per ulteriori informazioni sulla funzione COLLATE, consultare [Funzione COLLATE](r_COLLATE.md). ### Limitazioni del confronto di database Di seguito sono elencate le limitazioni nell'utilizzo del confronto di database in Amazon Redshift: + Tutte le tabelle o le viste di sistema, incluse le tabelle dei cataloghi PG e le tabelle di sistema di Amazon Redshift, fanno distinzione tra maiuscole e minuscole. + Quando il database consumer e il database producer hanno regole di confronto diverse a livello di database, Amazon Redshift non supporta query tra database e tra cluster. + Amazon Redshift non supporta il confronto senza distinzione tra maiuscole e minuscole nella query sul solo nodo principale. Nell'esempio seguente viene mostrata una query senza distinzione tra maiuscole e minuscole non supportata e l'errore restituito da Amazon Redshift: ``` SELECT collate(usename, 'case_insensitive') FROM pg_user; ERROR: Case insensitive collation is not supported in leader node only query. ``` + Amazon Redshift non supporta l'interazione tra le colonne con distinzione o senza distinzione tra maiuscole e minuscole, ad esempio operazioni di confronto, funzione, join o set. Negli esempi seguenti vengono mostrati gli errori restituiti quando interagiscono colonne con distinzione e senza distinzione tra maiuscole e minuscole: ``` CREATE TABLE test (ci_col varchar(10) COLLATE case_insensitive, cs_col varchar(10) COLLATE case_sensitive, cint int, cbigint bigint); ``` ``` SELECT ci_col = cs_col FROM test; ERROR: Query with different collations is not supported yet. ``` ``` SELECT concat(ci_col, cs_col) FROM test; ERROR: Query with different collations is not supported yet. ``` ``` SELECT ci_col FROM test UNION SELECT cs_col FROM test; ERROR: Query with different collations is not supported yet. ``` ``` SELECT * FROM test a, test b WHERE a.ci_col = b.cs_col; ERROR: Query with different collations is not supported yet. ``` ``` Select Coalesce(ci_col, cs_col) from test; ERROR: Query with different collations is not supported yet. ``` ``` Select case when cint > 0 then ci_col else cs_col end from test; ERROR: Query with different collations is not supported yet. ``` Per far funzionare queste query, utilizzare la funzione COLLATE per convertire il confronto di una colonna in modo che corrisponda all'altra. Per ulteriori informazioni, consulta [Funzione COLLATE](r_COLLATE.md). ## Esempi **Creazione di un database** Nell'esempio seguente viene creato un database denominato TICKIT e ne viene assegnata la proprietà all'utente DWUSER: ``` create database tickit with owner dwuser; ``` Per visualizzare i dettagli sui database, eseguire una query sulla tabella di catalogo PG\$1DATABASE\$1INFO. ``` select datname, datdba, datconnlimit from pg_database_info where datdba > 1; datname | datdba | datconnlimit -------------+--------+------------- admin | 100 | UNLIMITED reports | 100 | 100 tickit | 100 | 100 ``` L'esempio seguente crea un database denominato **sampledb** con livello di isolamento SNAPSHOT. ``` CREATE DATABASE sampledb ISOLATION LEVEL SNAPSHOT; ``` Nell'esempio seguente viene creato il database sales\$1db dall'unità di condivisione dati salesshare. ``` CREATE DATABASE sales_db FROM DATASHARE salesshare OF NAMESPACE '13b8833d-17c6-4f16-8fe4-1a018f5ed00d'; ``` ### Esempi di confronto di database **Creazione di un database senza distinzione tra maiuscole e minuscole** Nell'esempio seguente viene creato il database `sampledb`, la tabella `T1` e sono inseriti i dati nella tabella `T1`. ``` create database sampledb collate case_insensitive; ``` Esegui la connessione al nuovo database che hai appena creato usando il client SQL. Se usi l'Editor di query Amazon Redshift v2, scegli `sampledb` in **Editor**. Se usi RSQL, esegui un comando come il seguente. ``` \connect sampledb; ``` ``` CREATE TABLE T1 ( col1 Varchar(20) distkey sortkey ); ``` ``` INSERT INTO T1 VALUES ('bob'), ('john'), ('Mary'), ('JOHN'), ('Bob'); ``` Quindi la query trova i risultati con `John`. ``` SELECT * FROM T1 WHERE col1 = 'John'; col1 ------ john JOHN (2 row) ``` **Ordinamento senza distinzione tra maiuscole e minuscole** Nell'esempio seguente è mostrato l'ordinamento senza distinzione tra maiuscole e minuscole con la tabella T1. L’ordinamento di *Bob* e *bob* o *John* e *john* non è deterministico perché sono uguali nella colonna senza distinzione tra maiuscole e minuscole. ``` SELECT * FROM T1 ORDER BY 1; col1 ------ bob Bob JOHN john Mary (5 rows) ``` Analogamente, nell'esempio seguente è mostrato l'ordinamento senza distinzione tra maiuscole e minuscole con la clausola GROUP BY. *Bob* e *bob* sono uguali e appartengono allo stesso gruppo. È non deterministico ciò che si presenta nel risultato. ``` SELECT col1, count(*) FROM T1 GROUP BY 1; col1 | count -----+------ Mary | 1 bob | 2 JOHN | 2 (3 rows) ``` **Esecuzione di query con una funzione finestra su colonne senza distinzione tra maiuscole e minuscole** Nell'esempio seguente viene eseguita una query su una funzione finestra senza distinzione tra maiuscole e minuscole. ``` SELECT col1, rank() over (ORDER BY col1) FROM T1; col1 | rank -----+------ bob | 1 Bob | 1 john | 3 JOHN | 3 Mary | 5 (5 rows) ``` **Esecuzione di query con la parola chiave DISTINCT** Nell'esempio seguente viene eseguita una query sulla tabella `T1` con la parola chiave DISTINCT. ``` SELECT DISTINCT col1 FROM T1; col1 ------ bob Mary john (3 rows) ``` **Esecuzione di query con la clausola UNION** Nell'esempio seguente sono mostrati i risultati dell'UNION delle tabelle `T1` e `T2`. ``` CREATE TABLE T2 AS SELECT * FROM T1; ``` ``` SELECT col1 FROM T1 UNION SELECT col1 FROM T2; col1 ------ john bob Mary (3 rows) ```