Voxxed Days Bucharest 2023: NoSQL Endgame

The amount of data collected by applications nowadays is growing at a scary pace. Many of them need to handle billions of users generating and consuming data at an incredible speed. Maybe you are wondering how to create an application like this? What is required? What works best for your project?

In this session, we'll compare popular Java and JVM persistence frameworks for NoSQL databases.
We are going to look at Spring Data, Micronaut Data, Quarkus/Panache, Jakarta NoSQL and GORM (which indeed is actually a Marvel character in the Conan Universe ;-)
How do they compare, what are the strengths, weaknesses, differences and similarities? We'll show each of them with a selection of different NoSQL database systems (Key-Value, Document, Column, Graph) to learn how they take specific features and powers of a particular NoSQL type into consideration and provide support for.

Will there be a clear winner in the end, or maybe it depends on the particular DB type and use case and you might need more than one, with different strengths, just like the Avengers...?

Transcript

1. NoSQL Endgame Otávio Santana Werner Keil
2. Werner Keil Jakarta EE Specification Committee Member Let’s meet @otaviojava @wernerkeil Otávio Santana Distinguished Software Engineer, Zup Innovation
3. 3 5 trends in 2023
4. New digital trends create new technical challenges @otaviojava @wernerkeil
5. What are these challenges? @otaviojava @wernerkeil • Agile development process • High performance and availability • Manage huge data volumes
6. NoSQL FTW!
7. Advantages of NoSQL @otaviojava @wernerkeil • Handles large volumes of data at high-speed • Stores unstructured, semi-structured, or structured data • Easy updates to schemas and fields • Developer-friendly • Takes advantage of the cloud to deliver zero downtime
8. Why this talk Tons of persistence frameworks Which one performs best for your case? JVM can cope with heavy loads Would normally take ages to compare
9. NoSQL 01 Database 02 Doesn't use (semi)structure 03 No transactions 04 BASE Four different types 05
10. Key-Value stores AmazonS3 Apollo Ares Aphrodite Sun War Love Beauty AmazonDynamo Hazelcast Redis
11. Column-Oriented Apollo Aphrodite Ares Kratos Duty Duty Duty Dead Gods Love, happy Sun War 13 Color weapon Sword Row-key Columns HBase Scylla SimpleDB Cassandra DynamoDB Clouddata
12. Document stores { "name":"Diana", "duty":[ "Hunt", "Moon", "Nature" ], "siblings":{ "Apollo":"brother" } } ApacheCouchDB MongoDB Couchbase
13. Graph databases Apollo Ares Kratos was killed by was killed by killed killed Neo4j InfoGrid Sones HyperGraphDB
14. Time series InfluxDB KairosDB TimescaleDB
15. Multi-Model 01 02 03 04 OrientDB (graph, document) Couchbase (key value, document) Elasticsearch (document, graph) ArangoDB (document, graph, key-value)
16. SQL vs NoSQL SQL KEY-VALUE COLUMN DOCUMENTS GRAPH Table Bucket Column family Collection Row Key/value pair Column Documents Vertex Column Key/value pair Key/value pair Vertex and Edge property Relationship Link Edge
17. BASE vs ACID • Basically Available • Soft state • Eventual consistency • Atomicity • Consistency • Isolation • Durability
18. CAP
19. Scalability vs Complexity Scalability Complexity key-value Column Document Graph
20. Relational Application NoSQL Application Logic Tier Logic Tier DAO DAO JPA JPA JPA JPA JDBC JDBC JDBC JDBC Data Tier API API API Data Tier
21. Our comparison model
22. JPA problem for NoSQL 01 02 03 04 05 06 Saves Async Async Callback Time to Live (TTL) Consistency Level SQL based Diversity in NoSQL
23. Annotated Entities 01 02 03 Mapped Superclass Entity Column @Entity("god") public class God { @Column private String name; @Column private long age; @Column private Set<String> powers; }
24. Template God artemis = ...; DocumentTemplate template = … template.insert(artemis); template.update(artemis); DocumentQuery query = ... List<God> gods = template.select(query);
25. Repository interface GodRepository extends MongoRepository<God, String> { List<God> findByNameAndAge (String name, Integer age); }
26. Micronaut Data NoSQL
27. Repository @MongoRepository interface BookRepository extends CrudRepository<Book, ObjectId> { Book find(String title); } Or @MongoRepository public abstract class AbstractBookRepository implements CrudRepository<Book, ObjectId> { public abstract List<Book> findByTitle(String title); }
28. Entity @MappedEntity public class Book { @Id @GeneratedValue private ObjectId id; private String title; private int pages; public Book(String title, int pages) { this.title = title; this.pages = pages; } // ... }
29. Query by Text @MongoFindQuery(filter = "{title:{$regex: :t}}", sort = "{title: 1}") List<Book> customFind(String t); @MongoAggregateQuery("[{$match: {name:{$regex: :t}}}, {$sort: {name: 1}}, {$project: {name: 1}}]") List<Person> customAggregate(String t); @MongoUpdateQuery(filter = "{title:{$regex: :t}}", update = "{$set:{name: 'tom'}}") List<Book> customUpdate(String t); @MongoDeleteQuery(filter = "{title:{$regex: :t}}", collation = "{locale:'en_US', numericOrdering:true}") void customDelete(String t);
30. GORM NoSQL
31. Entity @Entity class User { ObjectId id String emailAddress String password String fullname Date dateCreated Date lastUpdated static constraints = { emailAddress email: true password nullable: true fullname blank: false } }}
32. @Document(collection = "gods") public class God { … } interface GodRepository extends MongoRepository<God, String> { … } What about the Controller? <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-mongodb</artifactId> </dependency> spring.data.mongodb.database=mythology spring.data.mongodb.port=27017 Logistics Domain
33. Our example
34. MovieEntity MovieRepository PersonEntity Roles … Other reactive dependencies … <dependency> <groupId>org.neo4j.springframework.data</groupId> <artifactId>spring-data-neo4j-rx-spring-boot-starter</artifactId> <version>1.1.1</version> </dependency> org.neo4j.driver.uri=bolt://localhost:7687 org.neo4j.driver.authentication.username=neo4j org.neo4j.driver.authentication.password=secret Logistics Domain
35. Repository public interface MovieRepository extends ReactiveNeo4jRepository<MovieEntity, String> { Mono<MovieEntity> findOneByTitle(String title); }
36. Entities @Node("Person") public class PersonEntity { @Id private final String name; private final Integer born; } @Node("Movie") public class MovieEntity { @Id private final String title; @Property("tagline") private final String description; @Relationship(type = "ACTED_IN", direction = INCOMING) private Map<PersonEntity, Roles> actorsAndRoles = new HashMap<>(); @Relationship(type = "DIRECTED", direction = INCOMING) private List<PersonEntity> directors = new ArrayList<>(); }
37. Relationships @RelationshipProperties public class Roles { private final List<String> roles; public Roles(List<String> roles) { this.roles = roles; } }
38. Quarkus NoSQL
39. Entity public class Person extends PanacheMongoEntity { public String name; public LocalDate birthDate; public Status status; // return name as uppercase in the model public String getName(){ return name.toUpperCase(); } // store all names in lowercase in the DB public void setName(String name){ this.name = name.toLowerCase(); } }
40. Repository @ApplicationScoped public class PersonRepository implements PanacheMongoRepository<Person> { // put your custom logic here as instance methods public Person findByName(String name){ return find("name", name).firstResult(); } public List<Person> findAlive(){ return list("status", Status.ALIVE); } public void deleteLoics(){ delete("name", "Loïc"); } }
41. Motivation BaseDocument baseDocument = new BaseDocument(); baseDocument.addAttribute(name, value); Document document = new Document(); document.append(name, value); JsonObject jsonObject = JsonObject.create(); jsonObject.put(name, value); ODocument document = new ODocument(“collection”); document.field(name, value);
42. Make NoSQL easier @Inject Template template; … template.insert(book); List<Book> books = template.select(Book.class) .where("title").eq("Effective Java").list();
43. Entity @Entity public class Person{ @Id private String id; @Column private String name; @Column private String city; } @Entity public record Book(@Id String id, @Column("title") String title, @Column("edition") int edition){}
44. Entity @Entity public class Person{ @Id private String id; @Column private String name; @Column private String city; } key value key key key value value value Column Family Graph Document Key Value
45. Template @Inject Template template; ... Car ferrari = template.insert(ferrari); Optional<Car> car = template.find(Car.class, 1L); List<Car> cars = template.select(Car.class).where("city").eq("Rome").result(); template.delete(Car.class).where("id").eq(1L).execute(); Optional<Car> result = template.singleResult("select * from Car where id = 1");
46. Templates Template DocumentTemplate KeyValueTemplate VendorTemplate VendorTemplate GraphTemplate ColumnTemplate
47. Jakarta Data NoSQL JPA Rest Client
48. Repository @Repository public interface CarRepository extends CrudRepository<Car, Long> { List<Car> findByType(CarType type); Optional<Car> findByName(String name); }
49. Repository @Inject CarRepository repository; ... Car ferrari = Car.id(10L).name("Ferrari").type(CarType.SPORT); repository.save(ferrari);
50. Pageable Repository @Repository public interface ProductRepository extends PageableRepository<Product, Long> { Page<Car> findByTypeOrderByName(CarType type, Pageable pageable); }
51. Diversity @Entity("god") public class God { @Column private String name; @UDT("weapon") @Column private Weapon weapon; } @Repository interface GodRepository extends CassandraRepository<God, String> { @CQL("select * from God where name = ?") List<God> findByName(String name); }
52. Repository with Queries @Repository interface PersonRepository extends CrudRepository<Person, Long> { @Query("select * from Person") Optional<Person> findByQuery(); @Query("select * from Person where id = @id") Optional<Person> findByQuery(@Param("id") String id); }
53. Conclusions @otaviojava @wernerkeil
54. Conclusions Switching between different NoSQL vendors not so easy ❌ Micronaut Data still supports very few NoSQL databases ❌ Still in Progress ❌ Often faster with a lower footprint and polyglot language support for Java, Kotlin and Groovy ✅
55. Conclusions Provides a cleaner and more readable DAO implementation ✅ Works with Grails, Micronaut or Spring Boot, polyglot language support for Java and Groovy ✅ Removes a lot of boiler-plate code ✅ Only 3 to 4 of the most popular NoSQL databases are supported out of the box, others require more effort or won’t work yet ❌
56. Conclusions Provides a cleaner and more readable DAO implementation ✅ Loosely coupled code makes switching between different NoSQL vendors just a matter of configuration ✅ Removes a lot of boiler-plate code ✅ Only a few popular NoSQL databases are supported out of the box at this moment ❌
57. Conclusions Switching between different NoSQL vendors not so easy ❌ Quarkus / Panache still supports very few NoSQL databases ❌ Removes a lot of boiler-plate code ✅ Can be faster with native GraalVM option Polyglot language support for Java or Kotlin ✅
58. Conclusions Still in Progress ❌ Supports a huge number of NoSQL database systems ✅ Loosely coupled code makes switching between different NoSQL vendors just a matter of configuration ✅ Removes boiler-plate code and provides a cleaner, more readable DAO ✅
59. ▪ GitHub repositories ▪ https://github.com/JNOSQL/nosql-endgame ▪ Project page ▪ http://jnosql.org ▪ Specifications ▪ Jakarta NoSQL: https://jakarta.ee/specifications/nosql/ ▪ Jakarta Data: https://jakarta.ee/specifications/data/ @wernerkeil Links @otaviojava
60. • Flaticon.com • Michael Simons • Jean Tessier • Teo Bais Credits @otaviojava @wernerkeil
61. Thank You @otaviojava @wernerkeil