NoSQL Endgame LWJUG 2021
Download as PPTX, PDF1 like79 views
This document discusses NoSQL Endgame, a framework for mapping object-relational mappings to NoSQL databases. It provides a cleaner DAO implementation and removes boilerplate code by supporting key-value stores, column-oriented, document, and graph databases. However, it only supports a few popular NoSQL databases out of the box and switching between vendors is not entirely easy. The framework is also outdated as the last release was in 2018.
![Document stores
{
"name":"Diana",
"duty":[
"Hunt",
"Moon",
"Nature"
],
"siblings":{
"Apollo":"brother"
}
}
ApacheCouchDB
MongoDB
Couchbase](https://image.slidesharecdn.com/lwjugnosqlendgame-210505173557/85/NoSQL-Endgame-LWJUG-2021-13-320.jpg)
NoSQL Endgame LWJUG 2021
- 1. NoSQL Endgame Our Partners 2021: Thodoris Bais Werner Keil
- 2. Werner Keil Thodoris Bais Jakarta EE Specification Committee Member Expert Group Member JSR-385 Let’s meet @thodorisbais @wernerkeil
- 3. @thodorisbais @wernerkeil ABN Amro Bank Financial sector Amsterdam Agile organization 20,000 3000+ 400+ Total number of employees Enterprise bank Headquarters Development Teams DevOps / Hybrid cloud Applications
- 4. 4 5 trends in 2021
- 5. New digital trends create new technical challenges @thodorisbais @wernerkeil
- 6. What are these challenges? @thodorisbais @wernerkeil • Agile development process • High performance and availability • Manage huge data volumes
- 7. NoSQL FTW!
- 8. Advantages of NoSQL @thodorisbais @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
- 9. 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
- 10. NoSQL 01 Database 02 Doesn't use (semi)structure 03 No transactions 04 BASE Four different types 05
- 11. Key-Value stores AmazonS3 Apollo Ares Aphrodite Sun War Love Beauty AmazonDynamo Hazelcast Redis
- 12. 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
- 14. Graph databases Apollo Ares Kratos was killed by was killed by killed killed Neo4j InfoGrid Sones HyperGraphDB
- 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
- 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
- 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. Repository @Inject @Database(DatabaseType.COLUMN) private GodRepository godRepository; @Inject @Database(DatabaseType.KEY_VALUE) private GodRepository godRepository;
- 27. Repository with Queries interface PersonRepository extends Repository<Person, Long> { @Query("select * from Person") Optional<Person> findByQuery(); @Query("select * from Person where id = @id") Optional<Person> findByQuery(@Param("id") String id); }
- 28. List<Movie> movies = documentTemplate.query("select * from Movie where year > 2012"); List<Person> people = columnTemplate.query("select * from Person where age = 25"); Optional<God> god = keyValueTemplate.query("get 'Ullr'"); List<City> cities = graphTemplate.query("g.V().hasLabel('City')"); Query by Text
- 30. Repository public class AnimalRepository { List<Animal> findByType(String type) {…} public Animal insert(Animal animal) {…} }
- 31. Entity public class City { private String name; public City(String name) { this.name = name; } public void setName(String name) { this.name = name; } public String getName() { return name; } }
- 32. Query by Text public void save(City city) { try (Session s = driver.session()) { String statement = "MERGE (c:City {id:$name.id}) ON CREATE SET c+=$name"; s.writeTransaction(tx -> tx.run(statement, singletonMap("name" ,city.asMap()))); } } public Stream<City> findByName(String name) { try (Session s = driver.session()) { String statement = "MATCH (c:City) WHERE c.name contains $name RETURN c"; return s.readTransaction(tx -> tx.run(statement, singletonMap("name", name))) .list(record -> new City(record.get("c").asMap())).stream(); } }
- 33. GORM NoSQL?
- 34. 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 } }}
- 35. @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
- 36. Our example
- 38. Repository public interface MovieRepository extends ReactiveNeo4jRepository<MovieEntity, String> { Mono<MovieEntity> findOneByTitle(String title); }
- 39. 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<>(); }
- 40. Relationships @RelationshipProperties public class Roles { private final List<String> roles; public Roles(List<String> roles) { this.roles = roles; } }
- 42. Entity @Entity public class Editor { @Id @GeneratedValue(generator = "uuid") @GenericGenerator(name = "uuid", strategy = "uuid2") private String editorId; private String editorName; @OneToMany(mappedBy = "editor", cascade = CascadeType.PERSIST) private Set<Author> assignedAuthors = new HashSet<>(); // constructors, getters and setters... }
- 43. Operations private void persistTestData(EntityManagerFactory entityManagerFactory, Editor editor) throws Exception { TransactionManager transactionManager = com.arjuna.ats.jta.TransactionManager.transactionManager(); transactionManager.begin(); EntityManager entityManager = entityManagerFactory.createEntityManager(); entityManager.persist(editor); entityManager.close(); transactionManager.commit(); }
- 44. Warning “In most cases, multi-document transaction incurs a greater performance cost over single document writes, and the availability of multi-document transactions should not be a replacement for effective schema design. For many scenarios, the denormalized data model (embedded documents and arrays) will continue to be optimal for your data and use cases. That is, for many scenarios, modeling your data appropriately will minimize the need for multi-document transactions.” Documentation
- 46. 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 ✅
- 47. Conclusions Switching between different NoSQL vendors not so easy ❌ Micronaut Data does not support NoSQL databases yet ❌ Still in Progress ❌ Often faster with a lower footprint and polyglot language support for Java, Kotlin and Groovy ✅
- 48. 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 ❌
- 49. 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 ❌
- 50. Conclusions Using a mapper for all scenarios is not a recommended approach ❌ Some JPA concepts are not easily mapped to the NoSQL world (e.g. transactions) ❌ No error-safe way to run the query language and hydrate DTOs from the result ❌ Outdated, no release since 2018 ❌
- 51. ▪ GitHub repositories ▪ https://github.com/JNOSQL/nosql-endgame ▪ Project page ▪ http://jnosql.org @thodorisbais @wernerkeil Links
- 52. 5 3 • Flaticon.com • Michael Simons • Jean Tessier Credits @thodorisbais @wernerkeil
- 53. Thank You ! Our Partners 2021: