Configure Table Groups e contagens de shards no Hologres para equilibrar o desempenho de consultas, o throughput de escrita e a eficiência de armazenamento entre cargas de trabalho.
Saiba como criar, consultar, modificar e excluir Table Groups, além de executar o resharding de tabelas quando sua carga de trabalho mudar.
Como funcionam os Table Groups e shards
Uma instância do Hologres organiza os dados em uma hierarquia de dois níveis:
Table Group -- Contêiner lógico que armazena uma ou mais tabelas. Todas as tabelas no mesmo Table Group compartilham a mesma contagem de shards.
Shard -- Unidade de distribuição de dados. Os shards são distribuídos entre os Workers (nós de computação) para processamento paralelo.
|
Conceito |
Função |
|
Instância |
Contém um ou mais bancos de dados, cada um com um ou mais Table Groups |
|
Table Group |
Agrupa tabelas que compartilham uma contagem de shards. Tabelas envolvidas em joins devem estar no mesmo Table Group. |
|
Shard |
Distribui dados entre os Workers para processamento paralelo |
|
Worker |
Nó de computação que processa um ou mais shards |
Cada banco de dados possui um Table Group padrão cuja contagem de shards corresponde às especificações da instância. A configuração padrão é suficiente para a maioria das cargas de trabalho.
Recomendações de configuração
Siga estas diretrizes:
Use o Table Group padrão, a menos que sua carga de trabalho exija uma contagem de shards diferente. As contagens de shards padrão por tamanho de instância estão listadas em Gerenciamento de instâncias.
-
Instâncias grandes (> 256 CUs): Considere usar múltiplos Table Groups para balanceamento de carga:
Grandes volumes de dados -- crie um Table Group separado com maior contagem de shards.
Muitas tabelas pequenas -- crie um Table Group separado com menor contagem de shards para reduzir a sobrecarga de inicialização de consultas.
Tabelas que participam de joins devem compartilhar um Table Group.
Evite criar um Table Group por tabela. Essa prática adiciona sobrecarga e fragmentação desnecessárias.
Alinhe a contagem de shards com os Workers. Defina a contagem de shards como múltiplo do número de Workers para garantir uso equilibrado de recursos e facilitar o scale-out.
Não é possível modificar a contagem de shards de um Table Group existente. Para alterar essa contagem, crie um novo Table Group e execute o resharding das suas tabelas para ele.
Limites de contagem de shards
A partir do Hologres V2.0, limites padrão impedem falhas de alocação causadas por excesso de shards. Exceder o limite retorna o erro too many shards in this instance.
Os limites seguem estas fórmulas:
Contagem máxima de shards por Table Group = Contagem de shards padrão x 2
Contagem total máxima de shards por instância = Contagem de shards padrão x 8
|
Especificações da instância |
Nós de computação padrão |
Shards padrão (V0.10.31+) |
Máximo de shards por Table Group (V2.0+) |
Máximo de shards por instância (V2.0+) |
|
32 CUs |
2 |
20 |
40 (20 x 2) |
160 (20 x 8) |
|
64 CUs |
4 |
40 |
80 (40 x 2) |
320 (40 x 8) |
|
96 CUs |
6 |
60 |
120 (60 x 2) |
480 (60 x 8) |
|
128 CUs |
8 |
80 |
160 (80 x 2) |
640 (80 x 8) |
|
160 CUs |
10 |
80 |
160 (80 x 2) |
640 (80 x 8) |
|
192 CUs |
12 |
80 |
160 (80 x 2) |
640 (80 x 8) |
|
256 CUs |
16 |
120 |
240 (120 x 2) |
960 (120 x 8) |
|
384 CUs |
24 |
160 |
320 (160 x 2) |
1280 (160 x 8) |
|
512 CUs |
32 |
160 |
320 (160 x 2) |
1280 (160 x 8) |
|
... |
... |
M |
M x 2 |
M x 8 |
Para desativar esses limites (não recomendado — pode causar falhas na alocação de recursos):
SET hg_experimental_enable_shard_count_cap = off;
Permissões
Somente um superusuário pode criar, modificar ou excluir um Table Group, ou mover uma tabela para um Table Group diferente (resharding).
Para conceder privilégios de superusuário a um usuário:
-- Replace <Alibaba Cloud account ID> with the user's UID.
-- For a RAM user, add the prefix "p4_" to the account ID.
ALTER USER "<Alibaba Cloud account ID>" SUPERUSER;
Atribuir uma nova tabela a um Table Group requer apenas permissões de criação de tabela.
Consulte metadados de Table Groups
Visualize o Table Group padrão
SELECT * FROM hologres.hg_table_group_properties
WHERE tablegroup_name IN (
SELECT tablegroup_name FROM hologres.hg_table_group_properties
WHERE property_key = 'is_default_tg' AND property_value = '1'
);
Saída de exemplo:
tablegroup_name | property_key | property_value
-----------------+------------------+----------------
test_tg_default | tg_version | 1
test_tg_default | table_num | 1
test_tg_default | is_default_tg | 1
test_tg_default | shard_count | 3
test_tg_default | replica_count | 1
test_tg_default | created_manually | 0
(6 rows)
Na saída, is_default_tg identifica o Table Group padrão e shard_count mostra sua contagem de shards.
Liste todos os Table Groups
SELECT tablegroup_name
FROM hologres.hg_table_group_properties GROUP BY tablegroup_name;
Visualize a contagem de shards de um Table Group
SELECT property_value AS shard_count
FROM hologres.hg_table_group_properties
WHERE property_key = 'shard_count' AND tablegroup_name = '<tg_name>';
Liste as tabelas em um Table Group
SELECT table_namespace AS schema_name, table_name
FROM hologres.hg_table_properties
WHERE property_key = 'table_group' AND property_value = '<tg_name>';
Encontre o Table Group de uma tabela
SELECT property_value AS table_group_name
FROM hologres.hg_table_properties
WHERE property_key = 'table_group' AND table_name = '<table_name>';
Crie um Table Group
CALL HG_CREATE_TABLE_GROUP('<new_tg_name>', <shard_count>);
|
Parâmetro |
Tipo |
Descrição |
|
|
Text |
Nome do Table Group |
|
|
INT4 |
Contagem de shards para o Table Group |
Exemplo:
-- Create a Table Group named tg_8 with 8 shards.
CALL HG_CREATE_TABLE_GROUP('tg_8', 8);
As tabelas existentes permanecem em seu Table Group original.
O Table Group original torna-se inválido somente após a movimentação ou exclusão de todas as suas tabelas e dados.
Altere o Table Group padrão
Defina um Table Group padrão diferente para atribuir novas tabelas a ele automaticamente.
Requer Hologres V0.9 ou posterior. Se sua instância estiver em uma versão anterior, atualize-a primeiro.
CALL HG_UPDATE_DATABASE_PROPERTY('default_table_group', '<tg_name>');
|
Parâmetro |
Tipo |
Descrição |
|
|
TEXT |
Nome do Table Group a ser definido como padrão. Sua contagem de shards torna-se o novo padrão para o banco de dados. |
Exemplo:
-- Set tg_8 as the default Table Group.
CALL HG_UPDATE_DATABASE_PROPERTY('default_table_group', 'tg_8');
Atribua uma nova tabela a um Table Group específico
Envolva as chamadas CREATE TABLE e SET_TABLE_PROPERTY em uma transação:
BEGIN;
CREATE TABLE <table_name> (
col1 text,
...
);
CALL SET_TABLE_PROPERTY('<table_name>', 'table_group', '<tg_name>');
COMMIT;
|
Parâmetro |
Tipo |
Descrição |
|
|
TEXT |
Nome da nova tabela |
|
|
TEXT |
Table Group de destino. A tabela herda a contagem de shards deste Table Group. |
Exemplo:
-- Create table tbl1 and assign it to Table Group tg_8.
BEGIN;
CREATE TABLE tbl1 (
col1 text
);
CALL SET_TABLE_PROPERTY('tbl1', 'table_group', 'tg_8');
COMMIT;
Execute o resharding de uma tabela
O scale-up de uma instância não ajusta a contagem de shards dos bancos de dados existentes. Para utilizar a capacidade adicionada, crie um novo Table Group com maior contagem de shards e mova suas tabelas para ele. Novos bancos de dados criados após o scale-up usam o padrão atualizado. Visão geral das especificações de instância.
Dois métodos estão disponíveis:
|
Método |
Tipos de tabela suportados |
Versão mínima |
|
Comando |
Tabelas não particionadas, particionadas fisicamente e particionadas logicamente (execução sequencial por partição) |
Hologres V3.1 |
|
Stored procedure |
Tabelas não particionadas e particionadas fisicamente |
Hologres V0.10 |
Resharding com REBUILD
A partir do Hologres V3.1, o comando REBUILD move tabelas entre Table Groups de forma assíncrona, com monitoramento de progresso em tempo real. REBUILD (Beta).
Resharding com stored procedure
A partir do Hologres V0.10, uma stored procedure integrada move uma tabela para um novo Table Group sem recriá-la ou reimportar dados.
Limitações
Requer Hologres V0.10 ou posterior. Verifique sua versão na página Instance Details. Se for anterior, atualize sua instância ou obtenha suporte online.
Interrompa todas as escritas durante o resharding. As leituras não são afetadas. A partir da V1.1, use
set table readonlypara failover automático de tarefas de escrita em tempo real.O resharding consome CPU e aumenta temporariamente o armazenamento. Execute fora do horário de pico.
Desative o binary log da tabela antes do resharding e reative-o depois. Assinar binary logs do Hologres.
Tabelas com campos
SERIALnão podem passar por resharding. Tabelas com valoresDEFAULTperdem o atributoDEFAULTapós o resharding.A tabela não deve depender de outros objetos, como views. Exclua as dependências antes do resharding; caso contrário, o Hologres retornará:
"ERROR: resharding table xxx can not executed because other objects depend on it.". Para contornar dependências de views, definaset hg_experimental_hg_insert_overwrite_enable_view=on;.O resharding aplica-se apenas ao Modelo de Permissão Simples (SPM). Modelo de permissões do Hologres.
O resharding não preserva propriedades de particionamento automático.
A partir do Hologres V2.0, comentários de colunas são preservados durante o resharding. Em versões anteriores, faça backup e restaure os comentários de colunas manualmente.
Sintaxe
Para V2.0.24 e posterior: Use o HoloWeb para executar o resharding por meio de uma interface gráfica. Resharding de tabelas.
Para versões anteriores: Execute os seguintes comandos SQL.
-- For V1.1 and later:
CALL HG_MOVE_TABLE_TO_TABLE_GROUP('<table_name>', '<new_table_group_name>');
-- For V0.10 and later:
CALL HG_UPDATE_TABLE_SHARD_COUNT('<table_name>', '<new_table_group_name>');
|
Parâmetro |
Descrição |
Exemplo |
|
|
Tabela a ser movida. Para uma tabela particionada, especifique a tabela pai. Execute o comando uma vez por tabela. |
|
|
|
Table Group de destino. |
|
Crie o novo Table Group antes de mover as tabelas. Criar um Table Group.
Interrompa todas as operações de escrita na tabela durante o resharding. As leituras não são afetadas.
Após mover todas as tabelas de um Table Group, exclua o Table Group vazio manualmente usando
HG_DROP_TABLE_GROUPse ele não for mais necessário.Para uma tabela particionada, opere apenas na tabela pai.
Em uma instância de virtual warehouse, o Virtual Warehouse líder do Table Group de destino deve executar a migração e acessar o Table Group de origem como follower. Autorizar um grupo de computação a acessar dados.
Trate exceções de resharding
Erros de OOM ou encerramento manual podem interromper o resharding. Se isso ocorrer, a tabela original torna-se somente leitura e uma tabela temporária chamada <initial_table_name>_xxxxxxxx aparece.
Para instâncias na V2.0.24 ou posterior:
HoloWeb: Continue ou cancele o resharding pela UI. Resharding de tabelas.
SQL: Siga as etapas abaixo.
Para instâncias em versões anteriores: Atualize para V2.0.24 ou posterior primeiro.
Para retomar o resharding, resolva a causa raiz e execute o comando HG_MOVE_TABLE_TO_TABLE_GROUP novamente.
Para cancelar o resharding e restaurar o estado original, execute estes comandos em ordem:
-- 1. Remove the read-only flag from the original table.
CALL set_table_property('<schema_name>.<table_name>', 'readonly', 'false');
-- 2. Find the temporary table name.
-- For a partitioned table:
SELECT schema_name, target_temp_table_name
FROM hologres.hg_resharding_properties
WHERE reshard_table_name = '<schema_name>.<table_name>' AND is_parent_table IS TRUE;
-- For a non-partitioned table:
SELECT schema_name, target_temp_table_name
FROM hologres.hg_resharding_properties
WHERE reshard_table_name = '<schema_name>.<table_name>'
AND is_parent_table IS FALSE AND is_sub_table IS FALSE;
-- 3. Drop the temporary table.
DROP TABLE IF EXISTS <schema_name>.<target_temp_table_name>;
-- 4. Clear the resharding progress record.
CALL hologres.hg_internal_clear_resharding_properties('<schema_name>.<table_name>');
Exclua um Table Group
Remova todas as tabelas do Table Group primeiro e, em seguida, execute:
CALL HG_DROP_TABLE_GROUP('<tg_name>');
Exemplo:
CALL HG_DROP_TABLE_GROUP('tg_8');
Verifique a distribuição de shards por worker
A distribuição desigual de shards entre os Workers causa desequilíbrio de carga e uso ineficiente de recursos.
A partir do Hologres V1.3, use a view de sistema worker_info para verificar o mapeamento de shards para Workers. Conceitos básicos aborda a relação entre shards e nós. Consultar a alocação de shards entre workers fornece a sintaxe da consulta.
Melhores práticas
O Table Group padrão atende à maioria das cargas de trabalho. Configurações personalizadas são abordadas em Melhores práticas para configurar table groups.
FAQ
O que significa o erro "internal error: Get rundown is not allowed in recovering state"?
Este erro indica que a tabela está no modo somente leitura, bloqueando operações INSERT, UPDATE e DELETE. O Hologres define esse estado quando o resharding é interrompido para evitar inconsistência de dados.
Para resolver:
-
Encontre todas as tabelas somente leitura:
SELECT * FROM hologres.hg_table_properties WHERE property_key = 'readonly' AND property_value = 'true'; -
Remova o sinalizador de somente leitura. Substitua
<table_name>pelo nome totalmente qualificado da tabela (por exemplo,public.my_table).CALL set_table_property('<table_name>', 'readonly', 'false');