Easy-Cassandra, a versão 2.0.1
Autor: Otávio Gonçalves de Santana | Publicado: 2014-02-13T19:33:00-03:00

Lançada a nova versão do Easy-Cassandra, a versão 2.0.1, dentre as novidades podemos citar;

Refatoração nos contrutores das fábricas de sessão
QueryBuilder (InsertBuilder, UpdateBuilder, DeleteBuilder, SelectBuilder e BatchBuilder)
Maior velocidade na leitura e escrita
Suporte nos processos assíncronos
Maior suporte ao Cassandra com Spring-Data

Um ponto importante é que para facilitar a configuração foi criada uma classe que é passada no parâmetro, a classe ClusterInformation, dessa maneira fica mais simples (além do código mais limpo, afinal sobrecarga de construtores não é uma boa prática) de se criar simples configurações para a fábrica. Como, por exemplo: 

ClusterInformation clusterInformation = ClusterInformation.create()
                .addHost(HOST)
                .withDefaultKeySpace(KEY_SPACE).withUser(USER).withPassword(PASS);
        easyCassandraManager = new EasyCassandraManager(clusterInformation);


Criando configuração para a fábrica de conexão

Dessa forma a configuração para usar o  Spring no Cassandra também mudou para:
<beans xmlns:context="http://www.springframework.org/schema/context" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xsi:schemalocation="http://www.springframework.org/schema/context
          http://www.springframework.org/schema/context/spring-context-3.0.xsd
          http://www.springframework.org/schema/beans
          http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">




 
 
  
   localhost
  
 



 
 
  
   org.easycassandra.persistence.cassandra.spring.entity.Contact
            org.easycassandra.bean.model.Step
            org.easycassandra.bean.model.Weight
  
 



 




Nova configuração do Spring no Easy-Cassandra

Talvez a melhoria mais marcante nessa versão são os recursos dos QueryBuilders, os queryBuilders são maneiras muito mais fácil de fazer interações com o Cassandra com configurações adversas de uma maneira mais simples, com ele é possível definir o nível de consistência, definir o timeStamp, quais campos serão manipulados.

 SimpleID id = new SimpleID();
    id.setIndex(ONE_HUNDRED_THIRTY);
    id.setKey(ONE_HUNDRED_THIRTY);
    UpdateBuilder update = template.updateBuilder(SimpleQueryBuilder.class, key);
    update.put("map", "name", "otavioMap").value("value", TEN_DOUBLE).execute();


Simples exemplo inserindo valores a partir da chave



UpdateBuilder update = persistence.updateBuilder(SimpleQueryBuilder.class);
 update.whereEq(Constant.KEY, Constant.ONE).whereEq(Constant.INDEX, Constant.ONE).addList("list", "otavioList").execute();


criando toda a query de atualização


 UpdateBuilder update = persistence.updateBuilder(SimpleQueryBuilder.class);
 update.whereEq(Constant.KEY, Constant.ONE).whereEq(Constant.INDEX, Constant.ONE).value("value", 12D).executeAsync(new ResultAsyncCallBack() {
    @Override
    public void result(Boolean bean) {
        // do some action
    }
});

 executando uma atualização assincronamente


InsertBuilder insert= persistence.updateBuilder(SimpleQueryBuilder.class);
Set set = new HashSet&lt;&gt;();
set.add("Linda");
Map map = new HashMap&lt;&gt;();
map.put("love", "Otavio and Poliana");
insert.value(Constant.KEY, Constant.ONE_HUNDRED).value(Constant.INDEX,
            Constant.ONE_HUNDRED).value(Constant.LIST_COLUMN, Arrays.asList("Poliana", "Otavio", "Love")).value(Constant.SET_COLUMN, set).value("map", map).execute();


Realizando inserção

  SimpleID id = new SimpleID();
    id.setIndex(ONE_HUNDRED_TWO);
    id.setKey(ONE_HUNDRED_TWO);
    SimpleBean simpleBean = new SimpleBean();
    simpleBean.setId(id);
    simpleBean.setValue(VALUE);
    InsertBuilder insert2 = persistence.updateBuilder(simpleBean);
    insert2.executeAsync((new ResultAsyncCallBack() {
    @Override
    public void result(Boolean bean) {
        // do some action
    }
    });

realizando inserção de modo assíncrono

  DeleteBuilder delete = persistence.deleteBuilder(SimpleQueryBuilder.class); 
    delete.whereEq(Constant.INDEX, ONE_HUNDRED_TWO).whereEq(Constant.KEY, ONE_HUNDRED_TWO).execute();

    DeleteBuilder delete2 = persistence.deleteBuilder(SimpleQueryBuilder.class,"map", "list", "set"); //Delete specific columns
    delete2 .whereEq(Constant.INDEX, ONE_HUNDRED_TWO).whereEq(Constant.KEY, ONE_HUNDRED_TWO).execute();


primeira query remove todas as colunas a partir da chave, na segunda query remove apenas os campos map, list e set.

 SimpleID id = new SimpleID();
    id.setIndex(ONE_HUNDRED_TWO);
    id.setKey(ONE_HUNDRED_TWO);

    DeleteBuilder delete2 = persistence.deleteBuilder(SimpleQueryBuilder.class, id);
    delete2.executeAsync((new ResultAsyncCallBack() {
    @Override
    public void result(Boolean bean) {
        // do some action
    }
    });

 remoção assíncrona



  SelectBuilder select = persistence.selectBuilder(SimpleQueryBuilder.class);
  select.eq("name", "name");
  select.in("index", ONE, TWO, THREE);
  List result = select.execute();


Realizando o select em que o campo nome é igual a nome e o indice está em um, dois e três.

SelectBuilder select = persistence.selectBuilder(SimpleQueryBuilder.class);
select.eq(NAME, NAME).gt("index", THREE).asc(INDEX).executeAsync(new ResultAsyncCallBack&gt;() {

        @Override
        public void result(List beans) {
          // do some thing
        }
    });

 Executando query assincronamente em que o indece seja mais que três e seja ordenado de forma descendente no índice.


O Batch é um recurso no cassandra que permite que se execute alterações no banco (inserção, atualização e remoção) de forma atômica, desse forma se pode enviar insert, updates e deletes como se fosse apenas uma requisição.

DeleteBuilder delete = dao.deleteBuilder();
    delete.whereEq(Constant.INDEX, Constant.ONE_HUNDRED_TWO)
            .whereEq(Constant.KEY, Constant.ONE_HUNDRED_TWO);

    InsertBuilder insert = dao.insertBuilder();
    insert.value(Constant.KEY, Constant.ONE_HUNDRED).value(Constant.INDEX,
            Constant.ONE_HUNDRED);
    insert.value(Constant.LIST_COLUMN,
            Arrays.asList("Poliana", "Otavio", "Love"));

    UpdateBuilder update = dao.update();
    update.whereEq(Constant.KEY, Constant.ONE).whereEq(Constant.INDEX, Constant.ONE);
    update.addList("list", "otavioList");

    BatchBuilder batchBuilder = dao.batchBuilder();

    batchBuilder.addOperations(delete, insert, update);
    batchBuilder.executeAsync(new ResultAsyncCallBack() {
        @Override
        public void result(Boolean bean) {
            // do some action
        }
    });

Executando processo de inserção, remoção e atualização de forma atômica com o BatchBuilder.

Vale lembrar que recurso do Batch deve ser usados em casos específicos, já que distribuir as requisições entre os nós, no cassandra, sempre será sua melhor amiga.
Esse artigo tem como objetivo ilustrar as mudanças dentro do Easy-Cassandra, se demonstrou dos recursos e da sua melhoria na velocidade a expectativa é que muitos mais recursos estejam por vir.

https://github.com/otaviojava/Easy-Cassandra/wiki/Builders
https://github.com/otaviojava/Easy-Cassandra/wiki
https://github.com/otaviojava/Easy-Cassandra/
https://github.com/otaviojava/Easy-Cassandra-samples