O que é a chave primária de hash e intervalo?

Não consigo entender qual é a chave primária do intervalo -

http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.html#WorkingWithTables.primary.key

e como isso funciona?

O que eles querem dizer com "índice de hash não ordenado no atributo de hash e um índice de intervalo classificado no atributo de intervalo"?

" Chave primária de hash e intervalo " significa que uma única linha no DynamoDB possui uma chave primária exclusiva composta pelas teclas hash e range . Por exemplo, com uma chave de hash X e uma chave de intervalo Y , sua chave primária é efetivamente XY . Você também pode ter várias chaves de intervalo para a mesma chave de hash, mas a combinação deve ser exclusiva, como XZ e XA . Vamos usar os exemplos deles para cada tipo de tabela:

Chave primária de hash - A chave primária é composta de um atributo, um atributo de hash. Por exemplo, uma tabela ProductCatalog pode ter ProductID como sua chave primária. O DynamoDB cria um índice de hash não ordenado nesse atributo de chave primária.

Isso significa que todas as linhas são excluídas desse valor. Cada linha no DynamoDB terá um valor exclusivo e obrigatório para esse atributo . Índice de hash não ordenado significa o que diz - os dados não são ordenados e você não recebe nenhuma garantia sobre como os dados são armazenados. Você não será capaz de fazer consultas em um índice não-ordenada , como Get Me todas as linhas que têm um maior ProductID do que X . Você escreve e busca itens com base na chave de hash. Por exemplo, Tirem-me a linha dessa tabela que tem ProductID X . Você está fazendo uma consulta com relação a um índice não ordenado, de modo que seus resultados são basicamente pesquisas de valor-chave, são muito rápidas e usam muito pouco rendimento.

Chave primária de hash e intervalo - a chave primária é composta por dois atributos. O primeiro atributo é o atributo hash e o segundo atributo é o atributo range. Por exemplo, a tabela Thread do fórum pode ter ForumName e Subject como sua chave principal, onde ForumName é o atributo de hash e Subject é o atributo de intervalo. O DynamoDB cria um índice de hash não ordenado no atributo de hash e um índice de intervalo classificado no atributo de intervalo.

Isso significa que a chave primária de cada linha é a combinação da chave de hash e de intervalo . Você pode obter diretos em linhas únicas se tiver as chaves hash e range, ou pode fazer uma consulta no índice do intervalo classificado . Por exemplo, obtenha- me todas as linhas da tabela com a chave Hash X que possuem chaves de intervalo maiores que Y ou outras consultas que afetam. Eles têm melhor desempenho e menos uso de capacidade em comparação com as Verificações e Consultas nos campos não indexados. Da documentação deles :

Os resultados da consulta são sempre classificados pela chave de intervalo. Se o tipo de dados da chave de intervalo for Number, os resultados serão retornados em ordem numérica; caso contrário, os resultados serão retornados na ordem dos valores do código de caracteres ASCII. Por padrão, a ordem de classificação é crescente. Para reverter a ordem, defina o parâmetro ScanIndexForward como false

Eu provavelmente perdi algumas coisas enquanto digitava isso e apenas arranhei a superfície. Há muito mais aspectos a serem levados em consideração ao trabalhar com tabelas do DynamoDB (taxa de transferência, consistência, capacidade, outros índices, distribuição de chaves etc.). Você deve dar uma olhada nas tabelas de amostra e na página de dados para obter exemplos.

Como a coisa toda está se misturando, vejamos a função e o código para simular o que isso significa

A única maneira de obter uma linha é através da chave primária

getRow(pk: PrimaryKey): Row

A estrutura de dados da chave primária pode ser esta:

// If you decide your primary key is just the partition key.
class PrimaryKey(partitionKey: String)

// and in thids case
getRow(somePartitionKey): Row

No entanto, você pode decidir que sua chave primária é chave de partição + chave de classificação neste caso:

// if you decide your primary key is partition key + sort key
class PrimaryKey(partitionKey: String, sortKey: String)

getRow(partitionKey, sortKey): Row
getMultipleRows(partitionKey): Row[]

Então a linha inferior:

1. Decidiu que sua chave primária é apenas chave de partição? obtenha uma linha por chave de partição.

2. Decidiu que sua chave primária é chave de partição + chave de classificação? 2.1 Obter uma linha por (chave de partição, chave de classificação) ou obter intervalo de linhas por (chave de partição)

De qualquer maneira, você obtém uma única linha por chave primária. A única questão é se você definiu essa chave primária como sendo apenas chave de partição ou chave de partição + chave de classificação

Os blocos de construção são:

1. Tabela
2. Item
3. Atributo KV.

Pense no Item como uma linha e no Atributo KV como células nessa linha.

1. Você pode obter um item (uma linha) pela chave primária.
2. Você pode obter vários itens (várias linhas) especificando (HashKey, RangeKeyQuery)

Você pode fazer (2) apenas se tiver decidido que sua PK é composta por (HashKey, SortKey).

Mais visualmente como é complexo, do jeito que eu vejo:

+----------------------------------------------------------------------------------+
|Table                                                                             |
|+------------------------------------------------------------------------------+  |
||Item                                                                          |  |
||+-----------+ +-----------+ +-----------+ +-----------+                       |  |
|||primaryKey | |kv attr    | |kv attr ...| |kv attr ...|                       |  |
||+-----------+ +-----------+ +-----------+ +-----------+                       |  |
|+------------------------------------------------------------------------------+  |
|+------------------------------------------------------------------------------+  |
||Item                                                                          |  |
||+-----------+ +-----------+ +-----------+ +-----------+ +-----------+         |  |
|||primaryKey | |kv attr    | |kv attr ...| |kv attr ...| |kv attr ...|         |  |
||+-----------+ +-----------+ +-----------+ +-----------+ +-----------+         |  |
|+------------------------------------------------------------------------------+  |
|                                                                                  |
+----------------------------------------------------------------------------------+

+----------------------------------------------------------------------------------+
|1. Always get item by PrimaryKey                                                  |
|2. PK is (Hash,RangeKey), great get MULTIPLE Items by Hash, filter/sort by range     |
|3. PK is HashKey: just get a SINGLE ITEM by hashKey                               |
|                                                      +--------------------------+|
|                                 +---------------+    |getByPK => getBy(1        ||
|                 +-----------+ +>|(HashKey,Range)|--->|hashKey, > < or startWith ||
|              +->|Composite  |-+ +---------------+    |of rangeKeys)             ||
|              |  +-----------+                        +--------------------------+|
|+-----------+ |                                                                   |
||PrimaryKey |-+                                                                   |
|+-----------+ |                                       +--------------------------+|
|              |  +-----------+   +---------------+    |getByPK => get by specific||
|              +->|HashType   |-->|get one item   |--->|hashKey                   ||
|                 +-----------+   +---------------+    |                          ||
|                                                      +--------------------------+|
+----------------------------------------------------------------------------------+

Então, o que está acontecendo acima? Observe as seguintes observações. Como dissemos, nossos dados pertencem a (Tabela, Item, KVAttribute). Todo item tem uma chave primária. Agora, a maneira como você compõe essa chave primária é significativa para como você pode acessar os dados.

Se você decidir que sua PrimaryKey é simplesmente uma chave de hash, então é ótimo obter um único item. Se você decidir, no entanto, que sua chave primária é hashKey + SortKey, também poderá fazer uma consulta de intervalo em sua chave primária, porque você receberá seus itens por (HashKey + SomeRangeFunction (na tecla de intervalo)). Assim, você pode obter vários itens com sua consulta de chave primária.

Nota: não me referi a índices secundários.

Uma resposta bem explicada já é dada pelo @mkobit, mas adicionarei uma imagem geral das teclas de intervalo e de hash.

Em poucas palavras, range + hash key = composite primary key CoreComponents of Dynamodb

Uma chave primária consiste em uma chave de hash e uma chave de faixa opcional. A tecla Hash é usada para selecionar a partição do DynamoDB. Partições são partes dos dados da tabela. As teclas de intervalo são usadas para classificar os itens na partição, se existirem.

Portanto, ambos têm um objetivo diferente e juntos ajudam a fazer consultas complexas. No exemplo acima hashkey1 can have multiple n-range.Outro exemplo de range e hashkey é game, userA (hashkey)pode jogar Ngame(range)

A tabela Música descrita em Tabelas, Itens e Atributos é um exemplo de tabela com uma chave primária composta (Artist e SongTitle). Você pode acessar qualquer item da tabela Música diretamente, se fornecer os valores Artista e SongTitle para esse item.

Uma chave primária composta oferece flexibilidade adicional ao consultar dados. Por exemplo, se você fornecer apenas o valor para Artista, o DynamoDB recuperará todas as músicas desse artista. Para recuperar apenas um subconjunto de músicas de um determinado artista, você pode fornecer um valor para o Artista junto com um intervalo de valores para o SongTitle.

https://www.slideshare.net/InfoQ/amazon-dynamodb-design-patterns-best-practices https://www.slideshare.net/AmazonWebServices/awsome-day-2016-module-4-databases-amazon-dynamodb -and-amazon-rds https://ceyhunozgun.blogspot.com/2017/04/implementing-object-persistence-with-dynamodb.html

@vnr, você pode recuperar todas as chaves de classificação associadas a uma chave de partição usando a consulta usando a chave de partição. Não há necessidade de digitalização. O ponto aqui é a chave de partição é obrigatória em uma consulta. A chave de classificação é usada apenas para obter o intervalo de dados