Criar e distribuir tabelas

APLICA-SE A: PostgreSQL

Neste exemplo, usaremos as tabelas distribuídas do Azure Cosmos DB for PostgreSQL para armazenar e consultar eventos registrados de colaboradores de código aberto do GitHub.

Pré-requisitos

Para seguir este início rápido, primeiro você precisará:

  1. Criar um cluster no Portal do Azure.
  2. Conectar-se ao cluster com psql para executar comandos SQL.

Criar tabelas

Depois de se conectar via psql, vamos criar nossa tabela. Copie e cole os seguintes comandos na janela do terminal psql e pressione ENTER para executar:

CREATE TABLE github_users
(
	user_id bigint,
	url text,
	login text,
	avatar_url text,
	gravatar_id text,
	display_login text
);

CREATE TABLE github_events
(
	event_id bigint,
	event_type text,
	event_public boolean,
	repo_id bigint,
	payload jsonb,
	repo jsonb,
	user_id bigint,
	org jsonb,
	created_at timestamp
);

CREATE INDEX event_type_index ON github_events (event_type);
CREATE INDEX payload_index ON github_events USING GIN (payload jsonb_path_ops);

Observe o índice GIN de payload em github_events. O índice permite consultas rápidas na coluna JSONB. Como o Citus é uma extensão do PostgreSQL, o Azure Cosmos DB for PostgreSQL dá suporte a recursos avançados do PostgreSQL, como o tipo de dados JSONB, para armazenar dados semiestruturados.

Distribuir tabelas

create_distributed_table() é a função magic que o Azure Cosmos DB for PostgreSQL fornece para distribuir tabelas e usar recursos em vários computadores. A função decompõe tabelas em fragmentos, que podem ser distribuídos entre nós para aumentar o desempenho de armazenamento e computação.

Observação

Em aplicativos reais, quando sua carga de trabalho se ajusta a 64 vCores, 256 GB de RAM e armazenamento de 2 TB, você pode usar um cluster de nó único. Nesse caso, a distribuição de tabelas é opcional. Posteriormente, você pode distribuir tabelas conforme necessário usando create_distributed_table_concurrently.

Vamos distribuir as tabelas:

SELECT create_distributed_table('github_users', 'user_id');
SELECT create_distributed_table('github_events', 'user_id');

Importante

A distribuição de tabelas é necessária para aproveitar os recursos de desempenho do Azure Cosmos DB for PostgreSQL. Se você não distribuir tabelas, os nós de trabalho não poderão ajudar a executar consultas que envolvam essas tabelas.

Carregar dados em tabelas distribuídas

Estamos prontos para preencher as tabelas com os dados de exemplo. Para este guia de início rápido, usaremos um conjunto de dados capturado anteriormente na API GitHub.

Usaremos a extensão pg_azure_storage para carregar os dados diretamente de um contêiner público no Armazenamento de Blobs do Azure. Primeiro, será necessário criar a extensão no banco de dados:

SELECT * FROM create_extension('azure_storage');

Execute os comandos a seguir para que o banco de dados busque os arquivos CSV de exemplo e carregue os arquivos nas tabelas do banco de dados.

-- download users and store in table

COPY github_users FROM 'https://pgquickstart.blob.core.windows.net/github/users.csv.gz';

-- download events and store in table

COPY github_events FROM 'https://pgquickstart.blob.core.windows.net/github/events.csv.gz';

Observe como a extensão reconheceu que as URLs fornecidas ao comando de cópia são do Armazenamento de Blobs do Azure, os arquivos que apontamos foram compactados com gzip, o que também foi tratado automaticamente para nós.

Podemos examinar detalhes de nossas tabelas distribuídas, incluindo os respectivos tamanhos, com a exibição citus_tables:

SELECT * FROM citus_tables;
  table_name   | citus_table_type | distribution_column | colocation_id | table_size | shard_count | table_owner | access_method 
---------------+------------------+---------------------+---------------+------------+-------------+-------------+---------------
 github_events | distributed      | user_id             |             1 | 388 MB     |          32 | citus       | heap
 github_users  | distributed      | user_id             |             1 | 39 MB      |          32 | citus       | heap
(2 rows)

Próximas etapas

Agora, distribuímos tabelas e as carregamos com os dados. Em seguida, vamos tentar executar consultas nas tabelas distribuídas.