Comment créer des ID auto increment dans Cassandra

Que Diriez-vous de ce qui suit, en utilisant Cassandra transactions légères

1 - Créer des Id de tableau:

CREATE TABLE ids (
  id_name varchar,
  next_id int,
  PRIMARY KEY (id_name)
)

2 - Insérez chaque id que vous souhaitez utiliser une séquence globale avec

Par exemple:

INSERT INTO ids (id_name, next_id)
VALUES ('person_id', 1)

3-ensuite, lors de l'insertion dans une table où vous souhaitez utiliser une touche auto-incrémentée, faites ce qui suit:

3.1 - Obtenir le next_id à partir de l'id de tableau:

SELECT next_id FROM ids WHERE id_name = 'person_id'

disons que le résultat est next_id = 1

3.2 - Incrément next_id, la façon suivante:

UPDATE ids SET next_id = 2 WHERE id_name = 'person_id' IF next_id = 1

Le résultat devrait ressembler à ceci:

[{[applied]: True}]

si elle a été mise à jour avec succès, ou

[{[applied]: False, next_id: 2}]

Si quelqu'un a déjà mis à jour.

donc, si vous avez True, utilisez id '1' - Il est à vous. Sinon, incrémentez next_id (ou utilisez simplement next_id retourné) et répétez le processus.

créer une séquence séquentielle globale de nombres n'a pas vraiment de sens dans un système distribué. Utilisez UUIDs.

(parce que vous auriez à faire tous les participants d'accord et accepter l'évolution de la séquence -- sous une implémentation naïve)

Il n'y a pas de bonne solution.

1. créez une colonne avec un nombre, augmentez le nombre et sauvegardez-le sur toutes les répliques avec un id temporaire, lisez toutes les répliques et vérifiez si l'id temporaire est "à vous", sinon recommencez.. pas une grande solution et ne sera pas échelle.

ou

1. Construisez votre propre service d'identification où vous allez chercher votre prochaine carte d'identité. Ce service ne sera exécuté que dans une seule instance et sera un scaling effrayant facteur.

dès que quelque chose va au-delà d'une seule instance, le séquençage des id devient compliqué, du moins si vous voulez qu'il soit mis à l'échelle. Cela inclut les bases de données relationnelles.

il existe un compteur type de données qui peut être utilisé. Considérons l'exemple ci-dessous.

CREATE KEYSPACE counterks WITH REPLICATION =
{ 'class' : 'NetworkTopologyStrategy', 'datacenter1' : 3 };

créer une table pour la colonne counter.

CREATE TABLE counterks.page_view_counts
(counter_value counter,
url_name varchar,
page_name varchar,
PRIMARY KEY (url_name, page_name)
);

Charger les données dans la colonne compteur.

UPDATE counterks.page_view_counts
SET counter_value = counter_value + 1
WHERE url_name='www.datastax.com' AND page_name='home';

jetez un oeil à la valeur du compteur.

SELECT * FROM counterks.page_view_counts;

Sortie:

 url_name         | page_name | counter_value
------------------+-----------+---------------
 www.datastax.com |      home |             1

augmenter la valeur du compteur.

 UPDATE counterks.page_view_counts
 SET counter_value = counter_value + 2
 WHERE url_name='www.datastax.com' AND page_name='home';

jetez un oeil à la valeur du compteur.

 url_name         | page_name | counter_value
------------------+-----------+---------------
www.datastax.com |      home |             3  

Consultez cette pour plus de détails: http://docs.datastax.com/en/cql/3.1/cql/cql_using/use_counter_t.html

cette question est assez ancienne mais j'aimerais la compléter avec une autre solution.

toute solution qui repose sur la synchronisation des noeuds est déraisonnable. Il est assez sûr de casser soit en bloquant la génération D'IDs ou en créant des IDS dupliqués.

MySQL way

vous pouvez reproduire la façon dont c'est fait avec la réplication maître-maître mysql avec le auto_increment_increment et auto_increment_offset paramètres.

pour le reproduire, vous devez connaître le nombre de noeuds ou le nombre maximum de noeuds attendus et vous devez créer un compteur (non-cassandra) (un fichier par exemple) sur chaque noeud.

chaque fois que vous voulez générer un nouveau nombre, vous trouvez la valeur courante, ajoutez l'incrément et sauvegardez-la. Si il n'existe pas encore, c'est le décalage.

Donc pour 10 nœuds, vous auriez un incrément de 10 et un décalage de 1 pour le premier noeud, 2 pour le deuxième noeud, etc. Le nœud 1 créerait les ID 1, 11, 21. Le noeud 2 créerait les IDs 2, 21, 22.

si vous voulez que vos Id soient (approximativement) ordonnés entre les noeuds, vous devez maintenir un compteur partagé et vous assurer que chaque ID généré est plus élevé que le compteur partagé. De cette façon, à moins que vos noeuds/datacenters ne soient hors de synchronisation pendant longtemps, vous ne devriez pas remarquer beaucoup de différence.

préfixe

vous pouvez faire essentiellement la même chose en préfixant L'ID (si c'est une solution acceptable) avec le numéro de noeud (ou le nom). Et vous n'avez pas connus le nombre de nœuds. Le noeud 1 créerait 1_1, 1_2, 1_3. Le noeud 2 créerait 2_1, 2_2, 2_3.

Edit: Cette solution n'est pas correcte. Voir le premier commentaire.

ma solution:

1 - Créer des Id de tableau:

CREATE TABLE ids (
  id_name varchar,
  next_id counter,
  PRIMARY KEY (id_name)
)

2 - lors de l'insertion dans une table où vous souhaitez utiliser une touche auto-incrémentée, faites ce qui suit:

2.1 - compteur D'incréments (il sera créé s'il n'existe pas), en utilisant le niveau de cohérence le plus élevé

UPDATE ids
  SET next_id = next_id + 1
  WHERE id_name = $AUTO_INCREMENTED_ID
  USING CONSISTENCY ALL

2.2 - Obtenir la nouvelle valeur de l'id:

SELECT next_id
  FROM ids
  WHERE id_name = $AUTO_INCREMENTED_ID

2.3-inscrire la valeur avec l'id auto-incrémenté

INSERT INTO some_table ($AUTO_INCREMENTED_ID, ...)
  VALUES ($RESULT_FROM_PREVIOUS_QUERY, ...)

les mots commençant par ' $ ' dans ma réponse sont des espaces vides explicites (j'espère)...

bien sûr, ce n'est pas une méthode recommandée. Utilisez - le SEULEMENT si vous le devez.

ils vraiment besoin d'être séquentiel, ou avez-vous juste besoin de compter des nombres qui sont beaucoup plus petits qu'un UUID qui sont facilement entrés par une personne?

si vous avez vraiment besoin de nombres séquentiels, alors vous devrez faire l'un des suivants.

• avoir une table dans cassandra où la clé/id est un champ pour le générateur, et la valeur est un nombre... faites des mises à jour conditionnelles dans une boucle jusqu'à ce que vous réussissiez à augmenter le nombre. (mauvais idée)

• avoir un service de générateur qui vous donnera le prochain numéro. Cela ne peut fonctionner que sur un seul système et être un seul point de défaillance, mais en fonction de vos besoins, cela pourrait être le mieux.

Alternativement... Similaire à la première, mais obtenir des lots d'une centaine de nombres à la fois, et distribuer ceux-ci à l'intérieur de votre processus/thread... Cela aura moins de contestation, mais aucune garantie d'ordre séquentiel, seulement unicité... Si vous voulez seulement plus courte numéros qui sont uniques pour l'affichage, il peut être votre meilleur pari.

je pense à mon humble avis attend à Cassandra pour fournir un champ d'incrémentation automatique est FAUX

Cassandra est une élégante base de données décentralisée, donc s'attendre à ce qu'elle fournisse un champ auto-incrémentant est, taxant et défait le but original, parce que cette valeur doit alors être maintenue dans un endroit central

par conséquent, ne faites pas de solution quelle DB basée pour obtenir un nombre auto-incrémentant

au lieu de générer L'ID dans le code ou le service dans votre application, qui peut continuer à générer des identifiants uniques aléatoires et utiliser cela pour appliquer sur votre modèle de données, de cette façon L'objectif et le bénéfice de Cassandra ne sera pas vaincu