Qu'est-ce que la clé primaire de hachage et de plage?

Je ne peux pas comprendre quelle clé primaire Range est ici -

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

et comment ça marche?

Que signifient-ils par "index de hachage non ordonné sur l'attribut de hachage et un index de plage trié sur l'attribut de plage"?

« Clé primaire de hachage et de plage » signifie qu'une seule ligne dans DynamoDB a une clé primaire unique composée à la fois du hachage et de la clé de plage . Par exemple, avec une clé de hachage de X et une clé de plage de Y , votre clé primaire est effectivement XY . Vous pouvez également avoir plusieurs clés de plage pour la même clé de hachage, mais la combinaison doit être unique, comme XZ et XA . Utilisons leurs exemples pour chaque type de table:

Hash Primary Key - La clé primaire est composée d'un attribut, un attribut de hachage. Par exemple, une table ProductCatalog peut avoir ProductID comme clé primaire. DynamoDB construit un index de hachage non ordonné sur cet attribut de clé primaire.

Cela signifie que chaque ligne est supprimée de cette valeur. Chaque ligne de DynamoDB aura une valeur unique requise pour cet attribut . Un indice de hachage non ordonné signifie ce qui est dit - les données ne sont pas ordonnées et vous n'avez aucune garantie sur la façon dont les données sont stockées. Vous ne serez pas en mesure de faire des requêtes sur un index non ordonné , comme Retrouve moi toutes les lignes qui ont une plus grande ProductID que X . Vous écrivez et récupérez des éléments en fonction de la clé de hachage. Par exemple, Donne- moi la ligne de cette table qui a ProductID X . Vous effectuez une requête sur un index non ordonné de sorte que vos résultats sont essentiellement des recherches de valeurs-clés, sont très rapides et utilisent très peu de débit.

Clé primaire de hachage et de plage - La clé primaire est composée de deux attributs. Le premier attribut est l'attribut de hachage et le deuxième attribut est l'attribut de plage. Par exemple, la table Thread du forum peut avoir ForumName et Subject comme clé primaire, où ForumName est l'attribut de hachage et Subject est l'attribut de plage. DynamoDB construit un index de hachage non ordonné sur l'attribut de hachage et un index de plage trié sur l'attribut de plage.

Cela signifie que la clé primaire de chaque ligne est la combinaison de la clé de hachage et de la plage . Vous pouvez effectuer des récupérations directes sur des lignes uniques si vous disposez à la fois de la clé de hachage et de la plage, ou vous pouvez effectuer une requête sur l' index de plage trié . Par exemple, obtenez Obtenez-moi toutes les lignes de la table avec la clé de hachage X qui ont des clés de plage supérieures à Y , ou d'autres requêtes qui affectent. Ils ont de meilleures performances et une utilisation de la capacité inférieure par rapport aux analyses et requêtes sur des champs qui ne sont pas indexés. De leur documentation :

Les résultats des requêtes sont toujours triés par la clé de plage. Si le type de données de la clé de plage est Number, les résultats sont renvoyés dans l'ordre numérique; sinon, les résultats sont renvoyés par ordre de valeurs de code de caractères ASCII. Par défaut, l'ordre de tri est croissant. Pour inverser l'ordre, définissez le paramètre ScanIndexForward sur false

J'ai probablement raté certaines choses en tapant ceci et je n'ai fait qu'effleurer la surface. Il y a beaucoup plus d' aspects à prendre en compte lorsque vous travaillez avec des tables DynamoDB (débit, cohérence, capacité, autres indices, distribution des clés, etc.). Vous devriez jeter un oeil aux exemples de tables et de page de données .

Alors que tout se mélange, regardons sa fonction et son code pour simuler ce que cela signifie

La seule façon d'obtenir une ligne est via la clé primaire

getRow(pk: PrimaryKey): Row

La structure des données de clé primaire peut être la suivante:

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

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

Cependant, vous pouvez décider que votre clé primaire est la clé de partition + la clé de tri dans ce cas:

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

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

Donc, la ligne de fond:

1. Vous avez décidé que votre clé primaire est uniquement une clé de partition? obtenir une seule ligne par clé de partition.

2. Vous avez décidé que votre clé primaire est la clé de partition + la clé de tri? 2.1 Récupérer une ligne par (clé de partition, clé de tri) ou obtenir une plage de lignes par (clé de partition)

Dans les deux cas, vous obtenez une seule ligne par clé primaire, la seule question est de savoir si vous avez défini cette clé primaire comme clé de partition uniquement ou clé de partition + clé de tri

Les blocs de construction sont:

1. Table
2. Article
3. Attribut KV.

Considérez l'article comme une ligne et l'attribut KV comme les cellules de cette ligne.

1. Vous pouvez obtenir un élément (une ligne) par clé primaire.
2. Vous pouvez obtenir plusieurs éléments (plusieurs lignes) en spécifiant (HashKey, RangeKeyQuery)

Vous ne pouvez faire (2) que si vous avez décidé que votre PK est composé de (HashKey, SortKey).

Plus visuellement que son complexe, la façon dont je le vois:

+----------------------------------------------------------------------------------+
|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                   ||
|                 +-----------+   +---------------+    |                          ||
|                                                      +--------------------------+|
+----------------------------------------------------------------------------------+

Alors qu'est-ce qui se passe ci-dessus. Notez les observations suivantes. Comme nous l'avons dit, nos données appartiennent à (Table, Item, KVAttribute). Ensuite, chaque élément a une clé primaire. Maintenant, la façon dont vous composez cette clé primaire est significative dans la façon dont vous pouvez accéder aux données.

Si vous décidez que votre PrimaryKey est simplement une clé de hachage, alors vous pouvez en retirer un seul élément. Si vous décidez cependant que votre clé primaire est hashKey + SortKey, vous pouvez également effectuer une requête de plage sur votre clé primaire, car vous obtiendrez vos éléments par (HashKey + SomeRangeFunction (sur la clé de plage)). Ainsi, vous pouvez obtenir plusieurs éléments avec votre requête de clé primaire.

Remarque: je n'ai pas fait référence aux index secondaires.

Une réponse bien expliquée est déjà donnée par @mkobit, mais j'ajouterai une vue d'ensemble de la clé de plage et de la clé de hachage.

En quelques mots range + hash key = composite primary key CoreComponents de Dynamodb

Une clé primaire est constituée d'une clé de hachage et d'une clé de plage facultative. La clé de hachage est utilisée pour sélectionner la partition DynamoDB. Les partitions font partie des données de la table. Les clés de plage sont utilisées pour trier les éléments de la partition, s'ils existent.

Les deux ont donc un objectif différent et contribuent ensemble à effectuer des requêtes complexes. Dans l'exemple ci-dessus hashkey1 can have multiple n-range.Un autre exemple de plage et de hachage est le jeu, l'utilisateurA (hashkey)peut jouer à Ngame(range)

La table Music décrite dans Tables, Items et Attributs est un exemple de table avec une clé primaire composite (Artist et SongTitle). Vous pouvez accéder directement à n'importe quel élément de la table Music si vous fournissez les valeurs Artist et SongTitle pour cet élément.

Une clé primaire composite vous offre une flexibilité supplémentaire lors de l'interrogation de données. Par exemple, si vous fournissez uniquement la valeur pour Artist, DynamoDB récupère toutes les chansons de cet artiste. Pour récupérer uniquement un sous-ensemble de chansons par un artiste particulier, vous pouvez fournir une valeur pour Artist ainsi qu'une plage de valeurs pour 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 -et-amazon-rds https://ceyhunozgun.blogspot.com/2017/04/implementing-object-persistence-with-dynamodb.html

@vnr, vous pouvez récupérer toutes les clés de tri associées à une clé de partition en utilisant simplement la requête à l'aide de la clé de partition. Pas besoin de scan. Le point ici est que la clé de partition est obligatoire dans une requête. Les clés de tri sont utilisées uniquement pour obtenir une plage de données