Diferença entre chave de partição, chave composta e chave de cluster no Cassandra?

Eu tenho lido artigos na rede para entender as diferenças entre os seguintes keytipos. Mas parece difícil para mim entender. Exemplos definitivamente ajudarão a melhorar a compreensão.

primary key,
partition key, 
composite key 
clustering key

Há muita confusão em torno disso, tentarei simplificar o máximo possível.

A chave primária é um conceito geral para indicar uma ou mais colunas usadas para recuperar dados de uma tabela.

A chave primária pode ser SIMPLES e até declarada em linha:

 create table stackoverflow_simple (
      key text PRIMARY KEY,
      data text      
  );

Isso significa que é feito por uma única coluna.

Mas a chave primária também pode ser COMPOSITE (também conhecida como COMPOUND ), gerada a partir de mais colunas.

 create table stackoverflow_composite (
      key_part_one text,
      key_part_two int,
      data text,
      PRIMARY KEY(key_part_one, key_part_two)      
  );

Em uma situação de chave primária COMPOSITE , a "primeira parte" da chave é chamada PARTITION KEY (neste exemplo, key_part_one é a chave de partição) e a segunda parte da chave é a CLUSTERING KEY (neste exemplo key_part_two )

Observe que a partição e a chave de cluster podem ser criadas por mais colunas ; veja como:

 create table stackoverflow_multiple (
      k_part_one text,
      k_part_two int,
      k_clust_one text,
      k_clust_two int,
      k_clust_three uuid,
      data text,
      PRIMARY KEY((k_part_one, k_part_two), k_clust_one, k_clust_two, k_clust_three)      
  );

Por trás desses nomes ...

• A chave de partição é responsável pela distribuição de dados entre seus nós.
• A chave de cluster é responsável pela classificação dos dados dentro da partição.
• A Chave Primária é equivalente à Chave de Partição em uma tabela de chave de campo único (ou seja, Simples ).
• A chave composta / composta é qualquer chave de várias colunas

Informações adicionais de uso: DOCUMENTAÇÃO DATASTAX

insert into stackoverflow_simple (key, data) VALUES ('han', 'solo');
select * from stackoverflow_simple where key='han';

conteúdo da tabela

key | data
----+------
han | solo

A tecla COMPOSITE / COMPOUND KEY pode recuperar "linhas largas" (ou seja, você pode consultar apenas a chave da partição, mesmo se tiver chaves de cluster definidas)

insert into stackoverflow_composite (key_part_one, key_part_two, data) VALUES ('ronaldo', 9, 'football player');
insert into stackoverflow_composite (key_part_one, key_part_two, data) VALUES ('ronaldo', 10, 'ex-football player');
select * from stackoverflow_composite where key_part_one = 'ronaldo';

conteúdo da tabela

 key_part_one | key_part_two | data
--------------+--------------+--------------------
      ronaldo |            9 |    football player
      ronaldo |           10 | ex-football player

Mas você pode consultar com todas as chaves (partição e cluster) ...

select * from stackoverflow_composite 
   where key_part_one = 'ronaldo' and key_part_two  = 10;

saída da consulta

 key_part_one | key_part_two | data
--------------+--------------+--------------------
      ronaldo |           10 | ex-football player

Nota importante: a chave da partição é o especificador mínimo necessário para executar uma consulta usando a where clause. Se você possui uma chave de partição composta, como o seguinte

por exemplo: PRIMARY KEY((col1, col2), col10, col4))

Você pode executar a consulta apenas passando pelo menos col1 e col2; essas são as 2 colunas que definem a chave da partição. A regra "geral" para fazer a consulta é que você deve passar pelo menos todas as colunas de chave da partição e adicionar opcionalmente cada chave de cluster na ordem em que elas estão definidas.

portanto, as consultas válidas são ( excluindo índices secundários )

• col1 e col2
• col1 e col2 e col10
• col1 e col2 e col10 e col 4

Inválido:

• col1 e col2 e col4
• qualquer coisa que não contenha col1 e col2

Espero que isto ajude.

A adição de uma resposta resumida como a aceita é bastante longa. Os termos "linha" e "coluna" são usados ​​no contexto do CQL, não como o Cassandra é realmente implementado.

• Uma chave primária identifica exclusivamente uma linha.
• Uma chave composta é uma chave formada a partir de várias colunas.
• Uma chave de partição é a pesquisa principal para encontrar um conjunto de linhas, ou seja, uma partição.
• Uma chave de cluster é a parte da chave primária que não é a chave da partição (e define a ordem dentro de uma partição).

Exemplos:

• PRIMARY KEY (a): A chave da partição é a.
• PRIMARY KEY (a, b): A chave da partição é a, a chave de cluster é b.
• PRIMARY KEY ((a, b)): A chave da partição composta é (a, b).
• PRIMARY KEY (a, b, c): A chave da partição é aa chave de cluster composta (b, c).
• PRIMARY KEY ((a, b), c): A chave de partição composta é (a, b), a chave de cluster é c.
• PRIMARY KEY ((a, b), c, d): A chave de partição composta é (a, b), a chave de cluster composta é (c, d).

No cassandra, a diferença entre chave primária, chave de partição, chave composta e chave de cluster sempre causa alguma confusão. Então, vou explicar a seguir e relacionar-me um com o outro. Usamos CQL (Cassandra Query Language) para acesso ao banco de dados do Cassandra. Nota: - A resposta é conforme a versão atualizada do Cassandra. Chave primária :-

No cassandra, existem 2 maneiras diferentes de usar a chave primária.

CREATE TABLE Cass (
    id int PRIMARY KEY,
    name text 
);

Create Table Cass (
   id int,
   name text,
   PRIMARY KEY(id) 
);

No CQL, a ordem na qual as colunas são definidas para a PRIMARY KEY é importante. A primeira coluna da chave é chamada de chave de partição, com a propriedade de que todas as linhas que compartilham a mesma chave de partição (mesmo na tabela) são armazenadas no mesmo nó físico. Além disso, a inserção / atualização / exclusão em linhas que compartilham a mesma chave de partição para uma determinada tabela são executadas atomicamente e isoladamente. Observe que é possível ter uma chave de partição composta, ou seja, uma chave de partição formada por várias colunas, usando um conjunto extra de parênteses para definir quais colunas formam a chave de partição.

Particionamento e clustering A definição PRIMARY KEY é composta de duas partes: a chave de partição e as colunas de clustering. A primeira parte é mapeada para a chave de linha do mecanismo de armazenamento, enquanto a segunda é usada para agrupar colunas em uma linha.

CREATE TABLE device_check (
  device_id   int,
  checked_at  timestamp,
  is_power    boolean,
  is_locked   boolean,
  PRIMARY KEY (device_id, checked_at)
);

Aqui o device_id é a chave da partição e o check_at é o cluster_key.

Também podemos ter várias chaves de cluster e de partição, o que depende da declaração.

Chave Primária : É composta por chave (s) de partição [e chaves (ou colunas) de clustering opcional]
Chave de Partição : O valor do hash da chave de Partição é usado para determinar o nó específico em um cluster para armazenar os dados
Chave de Cluster : É usado para classifique os dados em cada uma das partições (ou nó responsável e suas réplicas)

Chave primária composta : Como dito acima, as chaves de cluster são opcionais em uma Chave primária. Se não forem mencionados, é uma chave primária simples. Se as chaves de cluster são mencionadas, é uma chave primária composta.

Chave de partição composta : o uso de apenas uma coluna como chave de partição pode resultar em problemas de várias linhas (depende do caso de uso / modelagem de dados). Portanto, a chave da partição às vezes é especificada como uma combinação de mais de uma coluna.

Em relação à confusão de qual é obrigatório , qual pode ser ignorado etc. em uma consulta, tentando imaginar Cassandra como um HashMap gigante . Portanto, em um HashMap, você não pode recuperar os valores sem a Chave.
Aqui, as chaves da partição desempenham o papel dessa chave. Portanto, cada consulta precisa especificá-las. Sem o qual Cassandra não saberá qual nó procurar.
As chaves de cluster (colunas, que são opcionais) ajudam a restringir ainda mais sua pesquisa de consultas depois que Cassandra descobre o nó específico (e suas réplicas) responsável por essa chave de Partição específica.

Em um breve sentido:

Chave de Partição não passa de identificação para uma linha; essa identificação na maioria das vezes é a coluna única (chamada Chave Primária ) às vezes uma combinação de várias colunas (chamada Chave de Partição Composta ).

A chave de cluster nada mais é do que Indexação e Classificação . As chaves de cluster dependem de algumas coisas:

1. Quais colunas você usa na cláusula where, exceto as colunas da chave primária.

2. Se você tem registros muito grandes, então, com que preocupação posso dividir a data para facilitar o gerenciamento. Exemplo, tenho dados de 1 milhão de registros de população de um município. Portanto, para facilitar o gerenciamento, agrupo dados com base no estado e após o código PIN e assim por diante.

Vale notar que você provavelmente usará esses lotes mais do que em conceitos semelhantes no mundo relacional (chaves compostas).

Exemplo - suponha que você precise encontrar os últimos N usuários que ingressaram recentemente no grupo de usuários X. Como você faria isso com eficiência, considerando que as leituras predominam nesse caso? Assim (do guia oficial de Cassandra ):

CREATE TABLE group_join_dates (
    groupname text,
    joined timeuuid,
    join_date text,
    username text,
    email text,
    age int,
    PRIMARY KEY ((groupname, join_date), joined)
) WITH CLUSTERING ORDER BY (joined DESC)

Aqui, a chave de particionamento é composta por si mesma e a chave de cluster é uma data combinada . A razão pela qual uma chave de cluster é uma data de associação é que os resultados já estão classificados (e armazenados, o que torna as pesquisas mais rápidas). Mas por que usamos uma chave composta para particionar a chave ? Porque sempre queremos ler o mínimo possível de partições . Como colocar join_date lá ajuda? Agora, os usuários do mesmo grupo e da mesma data de associação residirão em uma única partição! Isso significa que sempre leremos o menor número possível de partições (primeiro comece com a mais nova, depois passe para a mais antiga e assim por diante, em vez de pular entre elas).

De fato, em casos extremos, você também precisaria usar o hash de um join_date em vez de um join_date sozinho - para que, se você pesquisar nos últimos 3 dias, muitas vezes eles compartilhem o mesmo hash e, portanto, estejam disponíveis na mesma partição!

A chave primária no Cassandra geralmente consiste em duas partes - chave de partição e colunas de cluster.

chave_primária ((chave_de_partição), coluna_de_ clustering)

Chave de partição - a primeira parte da chave primária. O principal objetivo de uma chave de partição é identificar o nó que armazena a linha específica.

CREATE TABLE phone_book (phone_num int, nome texto, idade int, cidade, PRIMARY KEY ((phone_num, nome), idade);

Aqui, (phone_num, name) é a chave da partição. Ao inserir os dados, o valor do hash da chave da partição é gerado e esse valor decide em qual nó a linha deve entrar.

Considere um cluster de 4 nós, cada nó tem um intervalo de valores de hash que pode armazenar. (Write) INSERT IN phone_book VALUES (7826573732, 'Joey', 25, 'New York');

Agora, o valor do hash da chave da partição é calculado pelo particionador Cassandra. digamos, valor de hash (7826573732, 'Joey') → 12, agora, esta linha será inserida no Nó C.

(Leia) SELECT * FROM phone_book WHERE phone_num = 7826573732 e name = 'Joey';

Agora, novamente o valor de hash da chave de partição (7826573732, 'Joey') é calculado, que é 12 no nosso caso, que reside no Nó C, a partir do qual a leitura é feita.

2. Colunas de cluster - segunda parte da chave primária. O principal objetivo de ter colunas de cluster é armazenar os dados em uma ordem classificada. Por padrão, o pedido está em ascensão.

Pode haver mais de uma chave de partição e colunas de cluster em uma chave primária, dependendo da consulta que você está solucionando.

chave_primária ((pk1, pk2), col 1, col2)

No design do banco de dados, uma chave composta é um conjunto de superchaves que não é mínimo.

Uma chave composta é um conjunto que contém uma chave composta e pelo menos um atributo que não é uma superchave

Tabela fornecida: EMPREGADOS {employee_id, nome, sobrenome}

As superchaves possíveis são:

{employee_id}
{employee_id, firstname}
{employee_id, firstname, surname}

{employee_id} é a única superchave mínima, o que também a torna a única chave candidata - já que {firstname} e {sobrenome} não garantem exclusividade. Como uma chave primária é definida como uma chave candidata escolhida e apenas uma chave candidata existe neste exemplo, {employee_id} é a superchave mínima, a única chave candidata e a única chave primária possível.

A lista exaustiva de chaves compostas é:

{employee_id, firstname}
{employee_id, surname}
{employee_id, firstname, surname}

A única chave composta é {employee_id, nome, sobrenome}, pois essa chave contém uma chave composta ({employee_id, firstname}) e um atributo que não é uma superchave ({sobrenome}).