En utilisant Cassandra et CQL3, comment insérer une ligne large entière dans une seule requête?

Question

Je veux insérer une seule ligne avec 50 000 colonnes dans Cassandra 1.2.8. Avant d'insérer, j'ai toutes les données pour toute la ligne prêt à aller (en mémoire):

+---------+------+------+------+------+-------+ 
|   | 0 | 1 | 2 | ... | 49999 | 
| row_id +------+------+------+------+-------+ 
|   | text | text | text | ... | text | 
+---------+------+------+------|------+-------+ 

Les noms de colonnes sont des nombres entiers, ce qui permet le découpage de pagination. Les valeurs de colonne sont une valeur à cet index particulier.

définition de la table CQL3:

create table results (
    row_id text, 
    index int, 
    value text, 
    primary key (row_id, index) 
) 
with compact storage; 

Comme je l'ai déjà row_id et toutes les paires nom 50 000/valeur en mémoire, je veux juste insérer une ligne unique dans Cassandra dans une seule requête/opération il est aussi vite que possible.

La seule chose que je peux sembler trouver est de faire exécuter les 50.000 heures suivantes:

INSERT INTO results (row_id, index, value) values (my_row_id, ?, ?); 

la première ? est est un compteur d'index (i) et la seconde ? est la valeur de texte pour stocker à emplacement i.

Cela prend beaucoup de temps. Même lorsque nous mettons les INSERT ci-dessus dans un lot, cela prend beaucoup de temps.

Nous avons toutes les données dont nous avons besoin (la ligne complète) dans son intégralité, je suppose qu'il est très facile de simplement dire "ici, Cassandra, stocker ces données en une seule ligne dans une demande", par exemple :

//EXAMPLE-BUT-INVALID CQL3 SYNTAX: 
insert into results (row_id, (index,value)) values 
    ((0,text0), (1,text1), (2,text2), ..., (N,textN)); 

Cet exemple n'est pas possible via la syntaxe CQL3 actuelle, mais j'espère que cela illustre l'effet désiré: tout serait inséré comme une seule requête.

Est-il possible de faire cela dans CQL3 et le pilote Java DataStax? Si non, je suppose que je serai obligé d'utiliser Hector ou le pilote Astyanax et l'opération Thrift batch_insert à la place?

Answer 1

Edit: seulement 4 jours après que j'ai posté cette question concernant Cassandra 1.2.9, Cassandra 2.0 a été libéré finale. 2.0 prend en charge les instructions préparées par lots, qui devrait être beaucoup plus rapide que la CQL3 non-batched qui devait être utilisée pour C * < 2.0.Nous n'avons pas encore testé cela pour être sûr.

Lorsque cette question a été publiée il y a 4 jours le 30 Août 2013, il n'a pas été possible dans CQL3 pour les versions C * moins de 2,0. Cela n'était possible que via un client Thrift, par ex. Astyanax MutationBatch.

Par la suggestion d'Alex, j'ai créé CASSANDRA-5959 comme une demande de fonctionnalité, mais il a été marqué comme un doublon à CASSANDRA-4693, qui a censément résolu le problème pour C * 2.0.

Answer 2

1. CQL3 déclaration INSERT ne prend pas en charge tuples de valeurs multiples. Mais je pense que cela pourrait faire un ajout intéressant à CQL alors s'il vous plaît submit a feature request. Le pilote Java DataStax est basé sur CQL. Il y a donc quelque chose à faire si l'instruction n'est pas supportée.

2. Pour le moment si vous avez besoin ce votre meilleure option serait d'utiliser une bibliothèque basée Thrift (nb : Je ne suis pas très familier avec l'API basée Thrift à confirmer cette insertion serait possible, mais Je pense qu'il devrait)

Answer 3

INSERTs/plusieurs mises à jour peuvent être effectuées en utilisant la méthode batch_mutate dans les API Thrift, en utilisant la mutation multi-cartes.

Map<byte[], Map<String, List<Mutation>>> mutationMap = new HashMap<byte[], Map<String, List<Mutation>>>(); 

List<Mutation> mutationList = new ArrayList<Mutation>(); 

mutationList.add(mutation); 
Map<String, List<Mutation>> m = new HashMap<String, List<Mutation>>(); 

m.put(columnFamily, mutationList); 

mutationMap.put(key, m); 
client.batch_mutate(mutationMap, ConsistencyLevel.ALL); 

Answer 4

utilisation Déclaration de lot dans CQL3 si vous voulez faire insérer plusieurs.

Avec C * 2.0, il sera encore plus facile et plus rapide car ils permettent la déclaration préparée par lots