NoSQL Endgame DevoxxUA Conference 2020
Download as PPTX, PDF0 likes157 views
The document discusses the challenges and advantages of NoSQL databases in the context of digital transformation within organizations, particularly focusing on the financial sector. It highlights various NoSQL data models, such as key-value, document, and graph databases, comparing them to traditional SQL databases in terms of scalability and complexity. Additionally, it touches on the use of microservices and frameworks like Micronaut for developing applications that utilize NoSQL technologies.
![Document stores
{
"name":"Diana",
"duty":[
"Hunt",
"Moon",
"Nature"
],
"siblings":{
"Apollo":"brother"
}
}
ApacheCouchDB
MongoDB
Couchbase](https://image.slidesharecdn.com/devoxx2020nosqlendgame-201106143814/85/NoSQL-Endgame-DevoxxUA-Conference-2020-13-320.jpg)
NoSQL Endgame DevoxxUA Conference 2020
- 1. NoSQL Endgame Otávio Santana Platform.sh Thodoris Bais ABN Amro & Utrecht JUG Werner Keil CATMedia
- 2. Werner Keil Thodoris Bais Jakarta EE Specification Committee Member Expert Group Member JSR-385 Let’s meet @thodorisbais@wernerkeil
- 3. Otavio Santana Developer Relations Engineer, Platform.sh Let’s meet @otaviojava
- 4. @thodorisbais@wernerkeil ABN Amro Bank Financial sector Amsterdam Agile organization 20,000 3000+ 400+ Total number of employeesEnterprise bank Headquarters Development Teams DevOps / Hybrid cloud Applications @otaviojava
- 5. 5 5 trends in 2020
- 6. New digital trends create new technical challenges @thodorisbais@wernerkeil @otaviojava
- 7. • Develop with agility • Operate at any scale • Deliver the performance and availability required to meet the demands of Digital Economy businesses What are the technical challenges?
- 8. 8 • Handle large volumes of data at high-speed with a scale-out architecture • Store unstructured, semi-structured, or structured data • Enable easy updates to schemas and fields • Developer-friendly • Take full advantage of the cloud to deliver zero downtime Advantages of NoSQL
- 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 structure 03 Not Transaction 04 Base Four different types05
- 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 ColumnsHBase 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 JPAJPAJPAJPA JDBC JDBCJDBCJDBC Data Tier APIAPI 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. Diversity @Entity("god") public class God { @Column private String name; @UDT("weapon") @Column private Weapon weapon; } interface GodRepository extends CassandraRepository<God, String> { @CQL("select * from God where name = ?") List<God> findByName(String name); }
- 29. 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
- 31. Repository public class AnimalRepository { List<Animal> findByType(String type) {…} public Animal insert(Animal animal) {…} }
- 32. 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; } }
- 33. 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(); } }
- 34. GORM NoSQL?
- 35. 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 } }}
- 36. @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
- 37. Our example
- 39. Repository public interface MovieRepository extends ReactiveNeo4jRepository<MovieEntity, String> { Mono<MovieEntity> findOneByTitle(String title); }
- 40. 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<>(); }
- 41. Relationships @RelationshipProperties public class Roles { private final List<String> roles; public Roles(List<String> roles) { this.roles = roles; } }
- 43. 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... }
- 44. 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(); }
- 45. 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. Entity @Entity(name = "book") @Indexed @Analyzer(impl = StandardAnalyzer.class) public class Book { @Id @DocumentId private Long isbn; @Column @Field(analyze = Analyze.NO) private String name; @Column @Field private String author; @Column @Field private String category; }
- 47. Operations EntityManagerFactory managerFactory = Persistence.createEntityManagerFactory("hibernate"); EntityManager manager = managerFactory.createEntityManager(); manager.getTransaction().begin(); Book cleanCode = getBook(1L, "Clean Code", "Robert Cecil Martin"); manager.merge(cleanCode); manager.getTransaction().commit(); Book book = manager.find(Book.class, 1L);
- 48. Warning “Cassandra does not use RDBMS ACID transactions with rollback or locking mechanisms... As a non-relational database, Cassandra does not support joins or foreign keys, and consequently does not offer consistency in the ACID sense.” DataStax Documentation
- 50. 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 ✅
- 51. 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 ✅
- 52. 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 ❌
- 53. 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 half a dozen popular NoSQL databases are supported out of the box, others require more effort or won’t work yet ❌
- 54. 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 ❌
- 55. ▪ GitHub repositories ▪ https://github.com/JNOSQL/nosql-endgame ▪ Project page ▪ http://jnosql.org @thodorisbais@wernerkeil Links
- 56. 5 6 • Flaticon.com • Michael Simons • Jean Tessier Credits @thodorisbais@wernerkeil
- 57. Thank You ! @thodorisbais@wernerkeil @otaviojava