Requêtes multi-critères avec Cassandra

Doing multi-criteria queries on a
Cassandra application

Ippon Technologies © 2015
Qui sommes-nous?
Jérôme Mainaud
○ Architecte Java chez Ippon Technologies
○ DataStax Solution Architect Certifié
Julien Dubois
○ 15 ans d’expérience en Java
○ Directeur de l’innovation chez Ippon Technologies
Ippon Technologies
○ Expertise Java & Big Data: consulting, formation, hébergement
○ 200 personnes
○ Paris, Bordeaux, Nantes, Richmond (USA)

Sommaire
1. Intro
2. Stack technique
3. Configuration du cluster
4. Application d’exemple
5. Recherche multi-critère
6. Utilisation de CQL3 avec Java 8
7. Limitations
8. Résultats

Stack technique

Stack technique
● JHipster
○ Générateur d’applications Spring Boot + AngularJS
○ Supporte JPA, MongoDB et… Cassandra!
● Nous a permis de générer l’application très rapidement
○ Squelette d’application prêt en 5 minutes
○ Ajout de tables avec leur mapping
○ Configuration, build, gestion des logs, etc.
○ Tests Gatling prêts à l’emploi
Plus d’informations sur http://jhipster.github.io/

Stack technique
● Spring Boot
○ Basé sur Spring
○ Convention over configuration
○ Nombreux “starters” prêts à l’emploi
● Services Web
○ CXF vs Spring MVC REST
● Cassandra
○ DataStax Enterprise

Paramétrage du Driver
● Configuration Spring Boot
○ Nous avons réalisé notre propre configuration du DataStax Java
Driver
○ Intégration dans la configuration standard de Spring Boot, utilisant
un fichier YAML
● Intégrée dans Spring Boot 1.3
○ Ce code a été proposé à Pivotal, et intégré dans Spring Boot 1.3
● Améliorée par PR
○ JHipster a été amélioré depuis, et propose toujours une
configuration plus complète que celle de Spring Boot

Développement des Repositories
● DataStax Java driver utilisé dans un Repository Spring
@Repository
public class UserRepository {
@Inject private Session session;
private PreparedStatement findOneByEmailStmt;
@PostConstruct
public void init() {
findOneByEmailStmt = session.prepare(
"SELECT id FROM user_by_email WHERE email = :email");
}
public Optional<User> findOneByEmail(String email) { … }

Configuration du cluster

Hardware
● Hébergement chez Ippon Hosting
● 8 noeuds équivalents
○ 16 Go de RAM
○ Deux disques durs SSD de 256 Go en RAID 0
● 6 noeuds pour le cluster Cassandra, 2 noeuds pour l’
application

DataStax Enterprise
● Utilisation de DataStax Enterprise
● OpsCenter nous a été d’une très grande aide
○ Monitoring
○ Services automatisés
○ Gestion du cluster

Application exemple
Système de gestion de factures

Modèle conceptuel

Modèle physique

create table invoice (
invoice_id timeuuid,
user_id uuid static,
firstname text static,
lastname text static,
invoice_date timestamp static,
payment_date timestamp static,
total_amount decimal static,
delivery_address text static,
delivery_city text static,
delivery_zipcode text static,
item_id timeuuid,
item_label text,
item_price decimal,
item_qty int,
item_total decimal,
primary key (invoice_id, item_id)
);
Table

Recherche multi-critère

Recherche multi-critères
Critères obligatoires
○ User (implicite)
○ Date de la facture (plage de dates)
Critères supplémentaires
○ Nom du client
○ Prénom du client
○ Ville
○ Code postal

Utiliser Solr ?

Utiliser Solr ?
● Intégré dans DataStax Enterprise
● Mise à jour atomique et automatique
● Recherche documentaire

Utiliser Solr ?
On cherche sur des colonnes statiques
Solr ne les gère pas
On cherche des partitions
Solr retourne des lignes

Index secondaires ?
● Ne répondent qu’aux cas de recherche sur un seul champ
● Délicats à utiliser avec de bonnes performances

Tables d’index
Utilisation de tables d’index
○ Clé de partition : Les critères primaire et un critère secondaire
■ user_id
■ date de facturation (tronqué à la date)
■ le critère secondaire
○ Clustering columns : l’identifiant de la facture

Recherche
Q1
Q2
A D J M
A C J L M
A J M
Fusion applicative
en mémoire
Recherches en parallèle

Recherche
Une page de résultat (id)
8f5b69ee-0ad0-11e5-a6c0-1697f925ec7b
8f5b6d4a-0ad0-11e5-a6c0-1697f925ec7b
8f5b6e9e-0ad0-11e5-a6c0-1697f925ec7b
b3db1a30-0ad0-11e5-a6c0-1697f925ec7b
b3db1c88-0ad0-11e5-a6c0-1697f925ec7b
b3db202a-0ad0-11e5-a6c0-1697f925ec7b
b3db219c-0ad0-11e5-a6c0-1697f925ec7b
cac5be94-0ad0-11e5-a6c0-1697f925ec7b
cac5c006-0ad0-11e5-a6c0-1697f925ec7b
cac5c150-0ad0-11e5-a6c0-1697f925ec7b
N recherches unitaires en parallèle

Recherche
Recherche sur une plage de dates
○ boucle sur les jours en s’arrêtant
dès qu’on a une page
de résultat

Recherche
Nombre de requêtes
○ Pour chaque jour dans la plage de dates
■ 1 requête par critère secondaire (partition by query)
○ 1 requête par élément trouvé (partition by query)
Complexité de la recherche
○ partitions by query
Exemple: 3 critères, 3 jours, 100 par pages
○ nombre de requêtes ≤ 3 × 3 + 100 = 109

JAVA

Index — instances
@Repository
public class InvoiceByLastNameRepository extends IndexRepository<String> {
public InvoiceByLastNameRepository() {
super("invoice_by_lastname", "lastname",
Invoice::getLastName, Criteria::getLastName);
}
}
@Repository
public class InvoiceByFirstNameRepository extends IndexRepository<String> {
public InvoiceByFirstNameRepository() {
super("invoice_by_firstname", "firstname",
Invoice::getFirstName, Criteria::getFirstName);
}
}

Index — classe parente
public class IndexRepository<T> {
@Inject
private Session session;
private final String tableName;
private final String valueName;
private final Function<Invoice, T> valueGetter;
private final Function<Criteria, T> criteriumGetter;
private PreparedStatement insertStmt;
private PreparedStatement findStmt;
private PreparedStatement findWithOffsetStmt;
@PostConstruct
public void init() { /* initialise les PreparedStatements */ }

Index — Écriture
@Override
public void insert(Invoice invoice) {
T value = valueGetter.apply(invoice);
if (value != null) {
session.execute(
insertStmt.bind(
invoice.getUserId(),
Dates.toDate(invoice.getInvoiceDay()),
value,
invoice.getId()));
}
}

Index — Écriture
insertStmt = session.prepare(
QueryBuilder.insertInto(tableName)
.value("user_id", bindMarker())
.value("invoice_day", bindMarker())
.value(valueName, bindMarker())
.value("invoice_id", bindMarker())
);
public static Date toDate(LocalDate date) {
return date == null ? null :
Date.from(date.atStartOfDay().atZone(ZoneOffset.systemDefault()).toInstant());
}

Index — Recherche
@Override
public CompletableFuture<Iterator<UUID>> find(Criteria criteria, LocalDate day, UUID offset) {
T criterium = criteriumGetter.apply(criteria);
if (criterium == null) {
return CompletableFuture.completedFuture(null);
}
BoundStatement stmt;
if (invoiceIdOffset == null) {
stmt = findStmt.bind(criteria.getUserId(), Dates.toDate(day), criterium);
} else {
stmt = findWithOffsetStmt.bind(criteria.getUserId(), Dates.toDate(day), criterium, offset);
}
return Jdk8.completableFuture(session.executeAsync(stmt))
.thenApply(rs -> Iterators.transform(rs.iterator(), row -> row.getUUID(0)));
}

Index — Recherche
findWithOffsetStmt = session.prepare(
QueryBuilder.select()
.column("invoice_id")
.from(tableName)
.where(eq("user_id", bindMarker()))
.and(eq("invoice_day", bindMarker()))
.and(eq(valueName, bindMarker()))
.and(lte("invoice_id", bindMarker()))
);

Index — Recherche (Guava to Java 8)
public static <T> CompletableFuture<T> completableFuture(ListenableFuture<T> guavaFuture) {
CompletableFuture<T> future = new CompletableFuture<>();
Futures.addCallback(guavaFuture, new FutureCallback<T>() {
@Override
public void onSuccess(V result) {
future.complete(result);
}
@Override
public void onFailure(Throwable t) {
future.completeExceptionally(t);
}
});
return future;
}

JAVA
Service de recherche

Service — Class
@Service
public class InvoiceSearchService {
@Inject
private InvoiceRepository invoiceRepository;
@Inject
private InvoiceByDayRepository byDayRepository;
@Inject
private InvoiceByLastNameRepository byLastNameRepository;
@Inject
private InvoiceByFirstNameRepository byLastNameRepository;
@Inject
private InvoiceByCityRepository byCityRepository;
@Inject
private InvoiceByZipCodeRepository byZipCodeRepository;

Service — recherche
public ResultPage findByCriteria(Criteria criteria) {
return byDateInteval(criteria, (crit, day, offset) -> {
CompletableFuture<Iterator<UUID>> futureUuidIt;
if (crit.hasIndexedCriteria()) {
/*
* ... Recherche multi-critère à voir dans la prochaine diapo ...
*/
} else {
futureUuidIt = byDayRepository.find(crit.getUserId(), day, offset);
}
return futureUuidIt;
});
}

Service — recherche
CompletableFuture<Iterator<UUID>>[] futures = Stream.<IndexRepository> of(
byLastNameRepository, byFirstNameRepository,
byCityRepository, byZipCodeRepository)
.map(repo -> repo.find(crit, day, offset))
.toArray(CompletableFuture[]::new);
futureUuidIt = CompletableFuture.allOf(futures).thenApply(v ->
Iterators.intersection(TimeUUIDComparator.desc,
Stream.of(futures)
.map(CompletableFuture::join)
.filter(Objects::nonNull)
.collect(Collectors.toList())));

Service — Comparaison des UUIDs
/**
* Comparateur de TimeUUID équivalent à celui de Cassandra:
* @see org.apache.cassandra.db.marshal.TimeUUIDType#compare()
*/
public enum TimeUUIDComparator implements Comparator<UUID> {
desc {
@Override
public int compare(UUID o1, UUID o2) {
long delta = o2.timestamp() - o1.timestamp();
if (delta != 0)
return Ints.saturatedCast(delta);
return o2.compareTo(o1);
}
};
}

Service — Boucle sur les jours
@FunctionalInterface
private static interface DayQuery {
CompletableFuture<Iterator<UUID>> find(Criteria criteria, LocalDate day, UUID invoiceIdOffset);
}
private ResultPage byDateInteval(Criteria criteria, DayQuery dayQuery) {
int limit = criteria.getLimit();
List<Invoice> resultList = new ArrayList<>(limit);
LocalDate dayOffset = criteria.getDayOffset();
UUID invoiceIdOffset = criteria.getInvoiceIdOffset();
/* ... Boucle sur les jours ; à voir dans la prochaine diapo ... */
return new ResultPage(resultList);
}

Service — Boucle sur les jours
LocalDate day = criteria.getLastDay();
do {
Iterator<UUID> uuidIt = dayQuery.find(criteria, day, invoiceIdOffset).join();
limit -= loadInvoices(resultList, uuidIt, criteria, limit);
if (uuidIt.hasNext()) {
return new ResultPage(resultList, day, uuidIt.next());
}
day = day.minusDays(1);
invoiceIdOffset = null;
} while (!day.isBefore(criteria.getFirstDay()));

Service — chargement des factures
private int loadInvoices(List<Invoice> resultList, Iterator<UUID> uuidIt,
Criteria criteria, int limit) {
List<CompletableFuture<Invoice>> futureList = new ArrayList<>(limit);
for (int i = 0; i < limit && uuidIt.hasNext(); ++i) {
futureList.add(invoiceRepository.findOne(uuidIt.next()));
}
futureList.stream()
.map(CompletableFuture::join)
.forEach(resultList::add);
return futureList.size();
}

Limitations

Limitations
La recherche ne fonctionne que sur un texte précis
○ Pas de recherche “plein texte”
○ Comme dans une base de données classique
La pagination ne donne pas le nombre total de pages de
résultats
Ce mécanisme ne peut fonctionner que s’il existe des critères
obligatoires fortement discriminants (ici: user_id et invoice_day)

Résultats

Résultats métier
● Gestion d’un an de données, sans limite
○ Nous comptons monter à 3 ans
○ Ancien système: limité à 3 mois
● Obtention des résultats en “temps réel”
○ Les données sont immédiatement disponibles
○ Ancien système: 24h de retard
● Coûts nettement plus bas

Résultats techniques
● Les tests Gatling ont montré que nous pouvions tenir
5000 utilisateurs concurrents
○ Sur des requêtes complexes, avec multiples critères et pagination
● Nous avons aussi démontré que le cluster était scalable
linéairement
○ En termes de volumétrie: ajout de nouveaux disques (passage en
JBOD)
○ En termes de performance: ajout de nouveaux noeuds à chaud

Merci à tous!

Requêtes multi-critères avec Cassandra

Contenu connexe

Tendances

Similaire à Requêtes multi-critères avec Cassandra

Plus de Julien Dubois

Dernier

Requêtes multi-critères avec Cassandra