O Amazon Redshift não permitirá mais a criação de UDFs do Python a partir do Patch 198. As UDFs do Python existentes continuarão a funcionar normalmente até 30 de junho de 2026. Para ter mais informações, consulte a [publicação de blog ](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/). 

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

Altera o banco de dados no qual as consultas são executadas. SHOW USE aponta para o banco de dados usado mais recentemente com o comando USE. RESET USE redefine o banco de dados usado. Isso significa que, se o banco de dados não for especificado no SQL, os objetos serão pesquisados no banco de dados atual.

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

```
USE database
```

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

Suponha que haja dois bancos de dados, `dev` e `pdb`, e `pdb2`. Considere que haja duas tabelas `t` nos esquemas públicos de cada um dos bancos de dados. Primeiro, insira os dados em tabelas de diferentes bancos de dados:

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

Se você não definir um banco de dados explicitamente, o sistema usará seu banco de dados conectado. Verifique o contexto atual do banco de dados:

```
dev=# show use;
Use Database

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

Se, ao consultar a tabela `t`, não for especificado um banco de dados, o sistema usará a tabela em seu banco de dados atual:

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

Use o comando `use` para alternar bancos de dados sem alterar sua conexão:

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

Também é possível especificar explicitamente o esquema.

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

Agora você pode criar tabelas em esquemas diferentes no banco de dados atual:

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

O caminho de pesquisa determina quais objetos do esquema são acessados quando você não especifica um esquema:

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

Altere a ordem dos esquemas para acessar tabelas diferentes:

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

Mude para outro banco de dados enquanto mantém sua conexão original:

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

Ao alternar bancos de dados, o caminho de pesquisa é redefinido para o padrão:

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

Crie uma tabela e insira dados no banco de dados atual:

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

Nas transações, você pode gravar no banco de dados atual e ler de qualquer banco de dados usando a notação de três partes. Isso também inclui o banco de dados conectado:

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

Redefina para seu banco de dados conectado. Observe que isso não só reverte para o banco de dados `pdb` usado anteriormente, mas redefine para o banco de dados conectado. O caminho de pesquisa também muda para o padrão: 

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

Você pode alterar os bancos de dados no início de uma transação, mas não depois de executar consultas:

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

### ARNs do Catálogo de Dados
<a name="use-redlake-example"></a>

Primeiro, crie tabelas em esquemas e catálogos diferentes para demonstrar consultas entre catálogos. Primeiro, crie tabelas no banco de dados conectado.

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

Depois, crie tabelas semelhantes em um catálogo diferente. Isso demonstra como trabalhar com bancos de dados de consulta entre catálogos.

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

Verifique o contexto atual do banco de dados. Se você não definir um banco de dados explicitamente, o sistema usará o banco de dados conectado.

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

Defina o banco de dados USEd para consultar tabelas em um catálogo diferente.

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

Ao consultar a tabela t, os resultados virão do banco de dados de consulta entre catálogos.

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

Altere o caminho de pesquisa para acessar tabelas em diferentes esquemas dentro do banco de dados USEd.

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

Embora USE esteja definido como um banco de dados de consulta entre catálogos, ainda é possível consultar explicitamente o banco de dados original.

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

Redefina o banco de dados USEd para que consulte novamente os objetos no banco de dados conectado.

```
dev=# RESET USE;

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

(1 row)
```

Observe que o search\$1path é redefinido quando USE é redefinido.

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

Após a redefinição, as consultas são direcionadas ao banco de dados conectado original.

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

Você pode modificar o caminho de pesquisa no banco de dados original para acessar esquemas diferentes.

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