CQL SÉLECTIONNEZ supérieur de la requête sur l'indexation non-colonne de clé

En CQL, vous êtes en mesure d'appliquer la WHERE clause sur toutes les colonnes, une fois que vous avez créé indices pour eux (c'est à dire, index secondaire). Sinon, vous obtiendrez l'erreur suivante:

Bad Request: No indexed columns present in by-columns clause with Equal operator

Malheureusement, même avec les indices, la clause where sont tenus d'avoir au moins un EQ sur un index secondaire par CQL en raison de problème de performance.

Q: Pourquoi est-il nécessaire de toujours avoir au moins un EQ comparaison sur
secondaire indices?

Un: les Inégalités en matière d'enseignement secondaire indices sont toujours
fait en mémoire, donc sans au moins un EQ sur un autre index secondaire
vous serez le chargement de chaque ligne dans la base de données, qui, avec un énorme
la base de données n'est pas une bonne idée. Donc, en exigeant au moins un EQ sur un
(secondaire) de l'indice, vous nous l'espérons limiter le nombre de lignes qui doivent être lues dans
la mémoire à une taille gérable. (Bien évidemment, vous pouvez toujours obtenir
des ennuis avec ça aussi).

Donc, fondamentalement, si vous avez quelque chose en plus d'un ÉGALISEUR de comparaison, il se charge de toutes les lignes "que elsewise match" à votre requête, et vérifie si elles correspondent, un à la fois. Ce qui n'est pas autorisé par défaut car il "peut être très lente." (En substance, les index seulement l'index "pour l'égalité" pas pour autre chose comme < et > index sur une base de données relationnelle serait).

Une chose à noter est que si vous avez plus d'un non ÉGALISATION des conditions sur les indices, vous devez également inclure le ALLOW FILTERING mot-clé dans votre requête, ou bien vous allez obtenir

Cannot execute this query as it might involve data filtering and thus may have unpredictable performance. If you want to execute this query despite the performance unpredictability, use ALLOW FILTERING

La manière la plus simple de contourner cette difficulté est d'ajouter un mannequin de la colonne de votre table, où toutes les lignes ont la même valeur sur cette colonne. Dans ce cas, vous êtes en mesure d'effectuer variait de requête sur votre colonne souhaitée. Faire réaliser que ce genre de requêtes sur une base de données NoSQL peut être lent/bog bas un système.

Exemple

cqlsh:demo> desc table table1;

CREATE TABLE table1 (
  keya int,
  keyb int,
  dummyvalue int,
  valuea int,
  PRIMARY KEY (keya, keyb)
) ....

cqlsh:demo> select * from Table1;

 keya | keyb | dummyvalue | valuea
------+------+------------+--------
    1 |    2 |          0 |      3
    4 |    5 |          0 |      6
    7 |    8 |          0 |      9

Créer secondaire indices sur ValueA et DummyValue:

cqlsh:demo> create index table1_valuea on table1 (valuea);
cqlsh:demo> create index table1_valueb on table1 (dummyvalue);

Allaient effectuer de requête sur ValueA avec DummyValue=0:

cqlsh:demo> select * from table1 where dummyvalue = 0 and valuea > 5 allow filtering;

 keya | keyb | dummyvalue | valuea
------+------+------------+--------
    4 |    5 |          0 |      6
    7 |    8 |          0 |      9

OriginalL'auteur keelar

CLÉ PRIMAIRE (KeyA, KeyB)
);

CRÉER un INDEX SUR la table Table1 (ValueA);

SELECT * from Table1 OÙ ValueA > 3000;

La Cassandra way est d'avoir une clé de partition et toujours l'utiliser, avec un regroupement de colonne pour ValueA éventuellement PRIMARY KEY ((KeyA, KeyB), ValueA) et ensuite utiliser comme:

select * from Table1 where KeyA='xx' and ValueA > 3000

OriginalL'auteur rogerdpack