BoundStatement est-il vraiment plus efficace que SimpleStatement à Cassandra?

Question

J'utilise respectivement SimpleStatement et BoundStatement pour sélectionner des données de Cassandra 100 fois.
J'ai trouvé que BoundStatement ne s'améliorait pas trop.

Cependant, this link dit:

SimpleStatement: une implémentation simple construite directement à partir d'une chaîne de caractères. Généralement utilisé pour les requêtes qui ne sont exécutées qu'une seule fois ou plusieurs fois.
BoundStatement: obtenu en liant des valeurs à une instruction préparée. Généralement utilisé pour les requêtes souvent exécutées avec des valeurs différentes.

Dans mon cas, pourquoi l'efficacité de SimpleStatement et BoundStatement est presque la même?

long start0 = System.currentTimeMillis(); 
    long start; 
    DataEntity mc = null; 
    ResultSet results = null; 
    BoundStatement bs = null; 
    PK pk = null; 
    CassandraData dao = new CassandraData(); 
    long end; 
    Session session = dao.getSession(); 

    //SimpleStatement ss = new SimpleStatement("select * from test where E='"+pk.E+"' and D="+pk.D+" and M="+pk.M); 

    PreparedStatement prepared = session.prepare(
      "select * from test where E=? and D=? and M=?"); 


    for (int i = 0; i < 100; i++) { 
     start = System.currentTimeMillis(); 
     pk = ValidData.getOnePk(); 

     //results = session.execute(ss); 

     bs = prepared.bind(pk.E, pk.D, pk.M); 
     results = session.execute(bs); 

     end = System.currentTimeMillis(); 
     logger.info("Show One:" + (end - start)/1000.0 + "s elapsed."); 
    } 

    long end0 = System.currentTimeMillis(); 
    logger.info("Show All:" + (end0 - start0)/1000.0 + "s elapsed."); 

Answer 1

C'est parce que vous faites trop moins d'itérations. 100 n'est pas suffisant pour voir la différence.

Mais à la fin, ils font tous les deux tout à fait bien le même travail, sauf que la simple déclaration:

• ne fournit qu'un seul voyage à noeud Cassandra.
• Ne laisse aucune instruction préparée stockée dans la mémoire des noeuds.

Alors ce qui rend le BoundStatement différent est que vous préparez une fois, se lient et de l'exécuter plusieurs fois. Par conséquent, une fois que vous avez préparé le BoundStatement, vous n'envoyez que les variables de liaison sur la connexion. Et pas toute la déclaration. Donc à partir de là, la différence d'efficacité devrait venir. Ce que vous pouvez faire d'autre est d'activer le suivi et de vérifier combien de temps l'instruction passe réellement et où.

Et pour les tests, je recommande de faire un peu de préchauffage avant de commencer à mesurer les temps. Comme il y a beaucoup de facteurs qui peuvent réellement affecter les résultats. PD: Je suppose que ValidData.getOnePk() renvoie des données aléatoires et que vous ne tapez pas dans le cache de ligne Cassandra.