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à.

# USE
<a name="r_USE_command"></a>

Modifica il database su cui vengono eseguite le query. SHOW USE punta al database che è stato utilizzato più di recente con il comando USE. RESET USE ripristina il database utilizzato. Ciò significa che, se il database non è specificato in SQL, gli oggetti vengono cercati nel database corrente.

## Sintassi
<a name="r_USE-synopsis"></a>

```
USE database
```

## Esempi
<a name="r_USE_command-examples"></a>

Supponiamo che esistano tre database: `dev`, `pdb` e`pdb2`. Lascia due tabelle `t` negli schemi pubblici di ciascuno dei database. Innanzitutto inserisci i dati nelle tabelle di diversi database:

```
dev=# insert into dev.public.t values (1);
INSERT 0 1
dev=# insert into pdb.public.t values (2);
INSERT 0 1
```

Senza impostare esplicitamente un database, il sistema utilizza il database connesso. Controlla il contesto attuale del database:

```
dev=# show use;
Use Database

(1 row)
dev=> show search_path;
search_path
$user, public
(1 row)
```

Quando esegui una query su una tabella `t` senza specificare un database, il sistema utilizza la tabella del database corrente:

```
dev=# select * from t;
c
----
1
(1 row)
```

Utilizza il comando `use` per cambiare database senza modificare la connessione:

```
dev=# use pdb;
USE
dev=# show use;
 Use Database
--------------
 pdb
(1 row)
dev=# select * from t;
id
----
2
(1 row)
```

Puoi anche specificare esplicitamente lo schema:

```
dev=# select * from public.t;
id
----
2
(1 row)
```

Ora puoi creare tabelle in diversi schemi all’interno del database corrente:

```
dev=# create table s1.t(id int);
CREATE TABLE
dev=# insert into pdb.s1.t values (3);
INSERT 0 1
```

Il percorso di ricerca determina a quali oggetti dello schema puoi accedere quando non specifichi uno schema:

```
dev=# set search_path to public, s1;
SET
dev=# select * from t;
 id
----
  2
(1 row)
```

Modifica l’ordine degli schemi per accedere a diverse tabelle:

```
dev=# set search_path to s1, public;
SET
dev=# show search_path;
 search_path
-------------
 s1, public
(1 row)
dev=# select * from t;
 id
----
  3
(1 row)
```

Passa a un altro database mantenendo la connessione originale:

```
dev=# show use;
 Use Database
--------------
 pdb
(1 row)
dev=# use pdb2;
USE
dev=# show use;
 Use Database
--------------
 pdb2
(1 row)
```

Quando cambi database, viene reimpostato il percorso di ricerca predefinito:

```
dev=# show search_path;
  search_path
---------------
 $user, public
(1 row)
```

Crea una tabella e inserisci i dati nel database corrente:

```
dev=# create table pdb2.public.t(id int);
CREATE TABLE
dev=# insert into pdb2.public.t values (4);
INSERT 0 1
dev=# select * from t;
 id
----
  4
(1 row)
```

Nelle transazioni puoi scrivere nel database corrente e leggere da qualsiasi database utilizzando una notazione in tre parti. È incluso anche il database connesso:

```
dev=# show use;
 Use Database
--------------
 pdb2
(1 row)

dev=# BEGIN;
BEGIN
dev=# select * from t;
 id
----
  4
(1 row)

dev=# insert into t values (5);
INSERT 0 1
dev=# select * from t;
 id
----
  4
  5
(2 rows)

dev=# select * from pdb.public.t;
 id
----
  2
(1 row)

dev=# select * from dev.public.t;
 id
----
  1
(1 row)
```

Ripristina il database connesso. Tieni presente che non viene solo ripristinato il database utilizzato in precedenza `pdb`, ma viene reimpostato anche il database connesso. Viene ripristinato anche il percorso di ricerca predefinito: 

```
dev=# RESET USE;
RESET
dev=# select * from t;
c
----
1
(1 row)
dev=# show use;
 Use Database
--------------

(1 row)

dev=# show search_path;
  search_path
---------------
 $user, public
(1 row)
```

Puoi modificare i database all’inizio di una transazione, ma non dopo avere eseguito le query:

```
dev=# BEGIN;
BEGIN
dev=# use pdb;
USE
dev=# use pdb2;
USE
dev=# use pdb;
USE
dev=# select * from t;
 id
----
  2
(1 row)
dev=# use pdb2;
ERROR:  USEd Database cannot be set or reset inside a transaction after another command.
dev=# rollback;
ROLLBACK
(1 row)
```

### Esempio del Catalogo dati
<a name="use-redlake-example"></a>

Innanzitutto crea tabelle in schemi e cataloghi diversi per dimostrare le query tra cataloghi. Inizia creando tabelle nel database connesso.

```
dev=# CREATE TABLE dev.public.t (col INT);
dev=# INSERT INTO dev.public.t VALUES (1);
dev=# CREATE SCHEMA write_schema;
dev=# CREATE TABLE dev.write_schema.t (state char (2));
dev=# INSERT INTO dev.write_schema.t VALUES ('WA');
```

A questo punto crea tabelle simili in un catalogo diverso. Di seguito viene dimostrato come utilizzare i database tra cataloghi.

```
dev=# CREATE TABLE my_db@my_catalog.public.t (col INT);
dev=# INSERT INTO my_db@my_catalog.public.t VALUES (100);
dev=# CREATE SCHEMA my_db@my_catalog.write_schema;
dev=# CREATE TABLE my_db@my_catalog.write_schema.t (state char (2));
dev=# INSERT INTO my_db@my_catalog.write_schema.t VALUES ('CA');
```

Controlla il contesto corrente del database. Senza impostare esplicitamente un database, il sistema utilizza il database connesso.

```
dev=# SHOW USE;
 Use Database
--------------

(1 row)

dev=# SHOW search_path;
  search_path
---------------
 $user, public
(1 row)

dev=# SELECT * FROM t;
 col
-----
   1
(1 row)
```

Imposta il USEd database per interrogare le tabelle in un catalogo diverso.

```
dev=# USE my_db@my_catalog;

dev=# SHOW USE;
            Use Database
-------------------------------------
 my_db@my_catalog
(1 row)

dev=# SHOW search_path;
  search_path
---------------
 $user, public
(1 row)
```

Quando esegui query sulla tabella t, i risultati provengono dal database tra cataloghi.

```
dev=# SELECT * FROM t;
 col
-----
 100
(1 row)

dev=# SELECT * FROM public.t;
 col
-----
 100
(1 row)

dev=# SELECT * FROM my_db@my_catalog.public.t;
 col
-----
 100
(1 row)
```

Modifica il percorso di ricerca per accedere alle tabelle in diversi schemi all'interno del USEd database.

```
dev=# SET search_path to write_schema;

dev=# SHOW search_path;
 search_path
--------------
 write_schema
(1 row)

dev=# SELECT * FROM t;
 state
-------
 CA
(1 row)

dev=# SELECT * FROM write_schema.t;
 state
-------
 CA
(1 row)

dev=# SELECT * FROM my_db@my_catalog.write_schema.t;
 state
-------
 CA
(1 row)
```

Anche se USE è impostato su un database tra cataloghi, è comunque possibile eseguire query esplicitamente sul database originale.

```
dev=# SELECT * FROM dev.write_schema.t;
 state
-------
 WA
(1 row)
```

Reimposta il USEd database per fare nuovamente riferimento agli oggetti nel database connesso.

```
dev=# RESET USE;

dev=# SHOW USE;
 Use Database
--------------

(1 row)
```

Tieni presente che search\$1path viene ripristinato quando viene ripristinato USE.

```
dev=# SHOW search_path;
  search_path
---------------
 $user, public
(1 row)
```

Dopo il ripristino, le query fanno riferimento al database connesso originale.

```
dev=# SELECT * FROM t;
 col
-----
   1
(1 row)

dev=# SELECT * FROM public.t;
 col
-----
   1
(1 row)

dev=# SELECT * FROM dev.public.t;
 col
-----
   1
(1 row)
```

Puoi modificare il percorso di ricerca nel database originale per accedere a schemi diversi.

```
dev=# SET search_path to write_schema;

dev=# SHOW search_path;
 search_path
--------------
 write_schema
(1 row)

dev=# SELECT * FROM t;
 state
-------
 WA
(1 row)

dev=# SELECT * FROM write_schema.t;
 state
-------
 WA
(1 row)

dev=# SELECT * FROM dev.write_schema.t;
 state
-------
 WA
(1 row)
```