Saiba mais sobre schemas, suas permissões e como utilizá-los. - MaxCompute: Central de Documentação do Alibaba Cloud

Os schemas permitem organizar tabelas, recursos e funções em grupos lógicos dentro de um projeto do MaxCompute, facilitando o gerenciamento granular.

Contexto

O projeto é a unidade organizacional básica do MaxCompute e atua como principal limite para isolamento multiusuário e controle de acesso.

Um projeto contém tabelas, recursos e funções. Anteriormente, esses objetos ficavam diretamente sob o projeto, que precisava atuar simultaneamente como banco de dados e schema. Essa estrutura dificultava o gerenciamento quando o projeto continha muitos objetos. O MaxCompute agora oferece suporte a schemas, que classificam tabelas, recursos e funções dentro de um projeto. A figura a seguir ilustra essa hierarquia. 层级图

Escopo

O recurso de schema está em melhoria contínua. Alguns módulos ainda não foram adaptados e só podem ser usados no modo set odps.namespace.schema=false.

Ferramentas de desenvolvimento
- O cliente do MaxCompute v0.40.8 e posterior oferece suporte ao recurso de schema.
- O plug-in MaxCompute Studio 4.0.0 e posterior oferece suporte ao recurso de schema.
Tipos de job
- Jobs Spark 3.1.1 e posteriores oferecem suporte ao recurso de schema.
- Defina o seguinte parâmetro para jobs Spark:
```
spark.sql.catalog.odps.enableNamespaceSchema=true
```
- Jobs Mars e MapReduce não oferecem suporte ao recurso de schema.
Outros produtos cloud
- O Hologres V1.3 e posterior oferece suporte ao recurso de schema. Para atualizar uma instância do Hologres, consulte Upgrade an instance.
- Outros produtos cloud, como PAI e Quick BI, não oferecem suporte ao recurso de schema personalizado.
Java SDK 0.40.8 e posterior, Java Database Connectivity (JDBC) 3.3.2 e posterior e PyODPS 0.11.3.1 e posterior oferecem suporte ao recurso de schema.
O DataWorks só interage com schemas no MaxCompute após a ativação do recurso schema no nível de tenant ou de projeto. Para mais informações, consulte DataWorks support for MaxCompute schemas.
Views e funções definidas pelo usuário (UDFs) criadas no modo odps.namespace.schema=false só podem ser acessadas nesse mesmo modo. A mesma regra se aplica ao modo odps.namespace.schema=true.

Termos principais

Schema

Classifica tabelas, recursos e UDFs dentro de um projeto. Um projeto pode conter vários schemas.
Chave de sintaxe de schema

Ao ativar a chave de sintaxe de schema, o sistema analisa instruções usando a semântica project.schema.table.
- Com a sintaxe de schema ativada, uma instrução no formato a.b.c é analisada como project.schema.table. Uma instrução no formato a.b é analisada como schema.table.
- Com a sintaxe de schema desativada, o sistema não reconhece instruções no formato a.b.c. Instruções no formato a.b são analisadas como project.table. Essa configuração pode ser definida no nível de tenant e no nível de job.
Schema padrão

Quando o recurso de schema está ativado, o sistema cria automaticamente um schema interno chamado DEFAULT em cada projeto. Não é possível excluir esse schema.
Configuração no nível de tenant

Define a semântica padrão para solicitações de acesso a dados enviadas por todo o tenant.
Configuração no nível de job

Essa configuração afeta apenas o job atual e tem prioridade sobre a configuração no nível de tenant. Execute o comando set odps.namespace.schema=true | false; para ativar ou desativar a sintaxe de schema.

Ativar o recurso

Se você é novo no MaxCompute e não possui projetos existentes, ative a chave de sintaxe no nível de tenant. Todos os novos projetos passarão a oferecer suporte ao recurso de schema, e todas as solicitações serão analisadas com base na sintaxe odps.namespace.schema = true por padrão.
1. Faça login no MaxCompute console e selecione uma região no canto superior esquerdo.
2. No painel de navegação à esquerda, escolha Manage Configurations > Tenants .
3. Na página Tenants, clique em Tenant Property.
4. Na aba Tenant Property, ative a chave Tenant-level Schema Syntax.
Caso tenha 10 ou menos projetos existentes e poucos ou nenhum job existente, siga estas etapas para adaptar seu ambiente. Após a adaptação, novos projetos oferecerão suporte a schemas, e todas as solicitações serão analisadas com base na sintaxe odps.namespace.schema=true por padrão.
1. Primeiro, atualize todos os projetos existentes para oferecer suporte a schemas.
  1. Faça login no MaxCompute console e selecione uma região no canto superior esquerdo.
  2. No painel de navegação à esquerda, escolha Manage Configurations > Projects.
  3. Na página Projects, clique em Enable Schema na coluna Actions do projeto desejado.
2. Em seguida, ative a opção Tenant-level Schema Syntax.
  1. No painel de navegação à esquerda, escolha Manage Configurations > Tenants .
  2. Na página Tenants, clique em Tenant Property.
  3. Na aba Tenant Property, ative a chave Tenant-level Schema Syntax.
Se você já possui projetos e jobs e precisa atualizar projetos específicos para oferecer suporte a schemas, siga estas etapas. Após a atualização, um Schema chamado DEFAULT é criado no projeto por padrão.
1. Faça login no MaxCompute console e selecione uma região no canto superior esquerdo.
2. No painel de navegação à esquerda, escolha Manage Configurations > Projects.
3. Na página Projects, clique em Enable Schema na coluna Actions do projeto desejado.
4. Todas as solicitações são analisadas com base na sintaxe odps.namespace.schema = false por padrão. Para um projeto atualizado, após criar um schema personalizado, ative a sintaxe de schema no nível de job executando set odps.namespace.schema=true; para acessar dados no schema personalizado.
- Se a sintaxe de schema estiver ativada, o caminho de dados para um projeto não atualizado será projectname.default.tablename.
- Se a sintaxe de schema estiver desativada, um projeto atualizado não poderá acessar schemas personalizados. O caminho projectname.tablename reconhece apenas dados no Schema chamado DEFAULT.

Observações de uso

Criar um projeto

Antes de usar schemas, create a MaxCompute project.
Ao criar um projeto no MaxCompute console, se a chave de sintaxe no nível de tenant estiver ativada (odps.namespace.schema = true), o projeto oferecerá suporte a schemas por padrão.

Gerenciar schemas

Gerenciar schemas usando comandos

Visualizar uma lista de schemas
```
SHOW schemas;
```
Criar um schema
```
CREATE schema <schema_name>;
```
schema_name especifica o nome do schema personalizado.
Visualizar informações do schema
```
DESC schema <schema_name>;
```
schema_name especifica o nome do schema.
Excluir um schema
```
DROP schema <schema_name>;
```
schema_name especifica o nome do schema. Antes de excluir um schema, exclua todas as tabelas e outros objetos de dados contidos nele. O comando DROP SCHEMA não oferece suporte a exclusão em cascata. Se existirem tabelas ou outros objetos no schema, o comando falhará e retornará um erro indicando que o schema não está vazio.

Gerenciar schemas usando o console de gerenciamento

Faça login no MaxCompute console e selecione uma região no canto superior esquerdo.
No painel de navegação à esquerda, escolha Manage Configurations > Projects.
Na página Projects, clique em Manage na coluna Actions do projeto desejado.
Na página Project Settings, clique em Schema.

A aba Schema fica visível apenas para projetos que oferecem suporte a schemas.
Na aba schema, visualize a lista de schemas e crie ou exclua schemas conforme necessário.

Operar objetos em um schema

Use o formato project.schema.table para referenciar objetos em um schema.

Nota

As referências a objetos Table neste tópico também se aplicam a objetos View, Resource e Function.

Ao operar uma tabela entre projetos, use o formato completo do comando: project.schema.table.
Para operações entre schemas no mesmo projeto, use o formato schema.table. Se um comando estiver no formato a.b, a será analisado como o schema, b será analisado como a tabela, e o projeto será o projeto atual.
Dentro do mesmo projeto, execute o comando use schema <schema_name> para especificar o schema atual. Em seguida, use diretamente um comando como select * from a. Nesse caso, a é a tabela, resolvida automaticamente para o projeto atual e o schema especificado.
Se nenhum schema for especificado no contexto e você usar um comando como select * from a, a será a tabela. Ela será resolvida automaticamente para o projeto atual e o schema chamado default.

Exemplos

Exemplo 1: Operar objetos em um schema dentro do mesmo projeto (projectA).

Operar objetos no schema default.

use projectA;
set odps.namespace.schema=true;-- If this is set at the tenant level, you do not need to specify it here.
-- Operate on table t_a
create table t_a(c1 string,c2 bigint);
INSERT OVERWRITE TABLE t_a VALUES ('a',1),('b',2),('c',3);
select * from t_a;
show tables;
desc t_a;

tunnel upload <path> t_a[/<pt_spc>];
tunnel download t_a[/pt_spc] <path>;

-- Operate on resource res_a.jar
add jar <path>/res_a.jar ;
desc resource res_a.jar;
list resources;
get resource res_a.jar D:\;
drop resource res_a.jar;

-- Operate on function fun_a
 create function fun_a as 'xx' using 'res_a.jar';
 desc function fun_a;
 list functions;
 drop function fun_a;

Os parâmetros são descritos da seguinte forma:

path: o caminho de armazenamento e o nome do arquivo.
pt_spc: Especifique a partição de nível mais baixo. O formato é partition_col1=col1_value1, partition_col2=col2_value1....

Operar objetos em schemas personalizados (s_1 e s_2), incluindo operações entre schemas.

use projectA;
set odps.namespace.schema=true;-- If this is set at the tenant level, you do not need to specify it here.

-- Operate on table t_c under s_1
use schema s_1;
create table t_c(c1 string,c2 bigint);
INSERT OVERWRITE TABLE t_c VALUES ('a',1),('b',2),('c',3);
select * from t_c;
show tables;
drop table t_c;

tunnel upload <path> t_c[/<pt_spc>];
tunnel download t_c[/pt_spc] <path>;

-- Operate on table t_d under s_2
create table s_2.t_d(c1 string,c2 bigint);
insert into/overwrite table s_2.t_d values ('a',1),('b',2),('c',3);
select * from s_2.t_d;
show tables in s_2;
drop table s_2.t_d;

tunnel upload <path> s_2.t_d[/<pt_spc>];
tunnel download s_2.t_d[/pt_spc] <path>;

-- Operate on resource res_b.jar under s_1
use schema s_1;
add jar <path>/res_b.jar  ;
desc resource res_b.jar;
list resources;
get resource res_b.jar D:\;
drop resource res_b.jar;

-- Operate on resource res_c.jar under s_2
add jar xxx ;-- The add resource command can only be run in the current schema or project. It cannot be run across schemas or projects. Therefore, you must switch to schema s_2 for normal operations.
-- For cross-project or cross-schema operations, use a colon (:) to separate resource levels.
desc resource s_2:res_c.jar;
list resources in s_2;
get resource s_2:res_c.jar D:\;
drop resource s_2:res_c.jar;

-- Operate on function fun_b under s_1
 use schema s_1;
 create function fun_b as 'xx' using 'res_b.jar'
 desc function fun_b;
 list functions;
 drop function fun_b;

 -- Operate on function fun_c under s_2
 create function s_2.fun_c as 'xx' using 's_2/resources/res_c.jar'
 drop function s_2.fun_c;
 desc function s_2.fun_c;
 list functions in s_2;
 drop function s_2.fun_c;

Exemplo 2: Executar operações entre projetos (operar objetos no ProjectB a partir do ProjectA).

use projectA;
set odps.namespace.schema=true;  -- If this is set at the tenant level, you do not need to specify it here.

-- Operate on table t_f in schema s_3 under projectB
create table projectB.s_3.t_f(c1 string,c2 bigint);
INSERT OVERWRITE TABLE projectB.s_3.t_f VALUES ('a',1),('b',2),('c',3);
select * from projectB.s_3.t_f;
show tables in projectB.s_3;
desc projectB.s_3.t_f;
drop table projectB.s_3.t_f;

tunnel upload <path> projectB.s_3.t_f[/<pt_spc>];
tunnel download projectB.s_3.t_f[/pt_spc] <path>;

-- Operate on resource res_f.jar in schema s_3 under projectB
add jar xxx ;-- The add resource command can only be run in the current schema or project. It cannot be run across schemas or projects. Therefore, you must switch to projectB and use schema s_3 for normal operations.
-- For cross-project and cross-schema operations, use a colon (:) to separate resource levels.
desc resource projectB:s_3:res_f.jar;
list resources in projectB.s_3;
get resource projectB:s_3:res_f.jar D:\;
drop resource projectB:s_3:res_f.jar;

-- Operate on function fun_f in schema s_3 under projectB
 create function projectB.s_3.fun_f as 'xx' using 'projectB/schemas/s_3/resources/res_f.jar'
 desc function projectB.s_3.fun_f;
 list functions in projectB.s_3;
 drop function projectB.s_3.fun_f;

Permissões

Conceder permissões em objetos de schema.

As permissões para operações em objetos de schema (CreateTable, CreateResource, CreateFunction) são concedidas no nível do projeto. Se você tiver essas permissões em um projeto, elas se aplicarão a todos os schemas desse projeto. O controle de acesso no nível de schema estará disponível em uma versão futura.
Nota
- O proprietário do schema possui, por padrão, todas as permissões de acesso e de controle de acesso para o schema e para os recursos contidos nele.
- Se você tiver as permissões CreateTable, CreateResource e CreateFunction em um projeto, herdará automaticamente as permissões correspondentes para os schemas desse projeto.

Permissões em objetos de recurso dentro de um schema.

Ao conceder permissões em um objeto de recurso dentro de um schema, especifique o nome completo do objeto (project.schema.table). Para obter uma lista de permissões no nível de objeto, consulte MaxCompute permissions. Também é possível conceder permissões no console de gerenciamento. Para mais informações, consulte Manage user permissions using the console.

-- Grant a role permissions on all tables in a schema.
GRANT <schemaObjectPrivileges> ON TABLE <project_name>.<schema_name>.* TO role {rolename};
-- Revoke from a role permissions on all tables in a schema.
REVOKE <schemaObjectPrivileges> ON TABLE <project_name>.<schema_name>.* FROM role {rolename};
-- Grant a role or user permissions on a specific table in a schema.
GRANT <schemaObjectPrivileges> ON TABLE <project_name>.<schema_name>.<tablename> TO {role|user} {rolename | USER name};-- Grant a role or user permissions on a specific table in a schema.
-- Revoke from a role or user permissions on a specific table in a schema.
REVOKE <schemaObjectPrivileges> ON TABLE <project_name>.<schema_name>.<tablename> FROM {role|user} {rolename | USER name};
-- View permissions on a table.
SHOW GRANTS ON TABLE <project_name>.<schema_name>.<tablename>;

Nota

O método de autorização com caractere curinga * é suportado apenas em instruções GRANT TO role e não é suportado em instruções GRANT TO user.
Para garantir a segurança dos dados, a sintaxe GRANT schemaObjectPrivileges ON TABLE <project_name>.<schema_name>.xxx* TO role {rolename}; não é suportada.