No-Nonsense NoSQL

by Jenn Strater

@jennstrater

Current

http://jlstrater.github.io/No-Nonsense-NoSQL

Slides(source)

Previous Versions

GreachSource |Slides

Iowa Code CampSource |Slides

Gr8Conf EUSource |Slides

About Me

Professional

Senior Consultant - Object Partners
Co-Founder - Gr8Ladies

About Me

Experience

source: http://tjvantoll.com/2014/12/29/so-you-want-to-write-a-tech-book/

About Me

Minneapolis, MN

Twitter @jennstrater
LinkedIn https://linkedin.com/in/jennstrater
Github https://github.com/jlstrater

Agenda

Review of Grails & Relational Databases
Gr8Ladies Example Application
NoSQL Definition
Types of NoSQL data stores
Example

MongoDB
Redis

What will NOT be covered

Every aspect of every NoSQL solution
Implementation, maintenance, or scaling of NoSql databases
Non-operational solutions

Search(i.e. Elasticsearch)
File systems And Processing(i.e Hadoop)

Review

Groovy

Dynamic, compiled language for the Java Virtual Machine(JVM).
Interoperable with existing Java libraries
Concise, easy to read code
Used by many major companies including:

Groovy is a dynamic compiled language for the JVM. That means it’s dynamic like languages you may know like Python and PHP, but compiled for efficiency to run on the Java Virtual Machine aka the JVM. Many of you may be asking, why learn yet another programming language? And granted, Groovy is not the best language for every situation. However, in a setting where productivity is paramount and you are looking for the stability of the known architecture stack like Java, Groovy is the best choice. As you’ll see, Groovy’s easy to learn, flexible syntax and interoperability with existing Java libraries, make it a great language to add to your repertoire. It's not just a prototyping solution and many companies use Groovy for enterprise solutions including Netflix, LinkedIn, and Mutual of Omaha.

Grails

Groovy Based
Model View Controller(MVC) Web framework for the JVM
Convention over Configuration
Features including:

Object Relational Mapper(ORM)
Domain-Specific Languages(DSL)
Runtime and compile-time Metaprogramming

Extensive Plugin Support
Open-source community driven Project

New in Grails 3

Based on Spring Boot
Switched to Gradle for build system
Major structural changes

Configuration
Scripts

Relational Databases

Tabular
Defined Schema
Relationships between data
Terms

Database
Table
Row
Column

Example Task

Gr8Ladies Products

Catalog Products
Shopping Cart

Code Samples

class Product {

  String name
  Vendor vendor
  String chapter
  String imageUrl
  String vendorUrlPath
  SortedSet priceQuantityRelations
  Integer minQuantity
  
  static hasMany = [priceQuantityRelations: PriceQuantityRelation]
  
  static constraints = {
      chapter nullable: true
      imageUrl nullable: true
      minQuantity min: 1
  }
  
  static mapping = {
      priceQuantityRelations sort: 'quantity'
  }
}

package org.gr8ladies

class Vendor {

    String name
    String url
    
    static constraints = {
        url(url: true)
    }
}

class PriceQuantityRelation implements Comparable {

    BigDecimal price
    Integer quantity
    BigDecimal unitPrice
    
    static belongsTo = [product: Product]
    
    static constraints = {
        quantity min: 1
        price min: 0.00, scale: 2
        unitPrice min: 0.00, scale: 4
    }
    
    String getDisplayName() {
        quantity + ' for $' + price + '($' + unitPrice + ' each)'
    }
    
    int compareTo(obj) {
        quantity.compareTo(obj.quantity)
    }
}

class Cart {
    String userSession
    
    static hasMany = [cartItems: CartItem]
    
    static constraints = {
    }
    
    Integer getSize() {
        this.cartItems?.size() ?: 0
    }
    
    BigDecimal getTotalPrice() {
        BigDecimal sum = cartItems?.sum { item ->
            item.priceQuantityRelation.unitPrice *
            item.priceQuantityRelation.quantity
        }
        sum ? sum.setScale(2) : 0.00
    }
}

package org.gr8ladies

class CartItem {

    PriceQuantityRelation priceQuantityRelation
    
    static belongsTo = [cart: Cart]
    
    static constraints = {
    }
}

What is NoSQL?

Not Only SQL
Group of data storage solutions that are not Relational Database Management System(RDBMS)

Schema-less
Non-relational

Originally NoSQL was used to refer to databases that did not use SQL or as 'not sql'. Over time, the phrase has evolved to mean Not Only SQL. As a broad definition, NoSQL describes a group of storage solutions that are not tabular like traditional relational databases.

Goals of NoSQL

Volume
Velocity
Dependability

NoSQL solutions try to solve problems of high volumes of data(more than fits on a single disk), many requests at the same time, and increased uptime. Many of these solutions do so through distributing data over many nodes. Some solutions do this better than others. As with most things(and a theme throughout this talk), optimizing for any one characteristic comes with trade-offs.

CAP Theorem

modified from source: http://www.momahler.com/ProArtistManifesto

Types of NoSQL solutions

Aggregate Stores

Key-value
Document
Column

Graph

Key-value Stores

Uses

Content Caching
Transient Data

Session Data

Image Stores

Examples

MemCached
DynamoDB^*
Redis^*
Amazon S3

Considerations

Relationships
Transactions
Querying

Libraries & Plugins

		Status
	Jedis
	Grails Redis
	Redis GORM	Last Updated June 2014
	Memcached 2nd-Level Cache Plugin	Last Updated December 2011
	DynamoDB GORM	Last Updated April 2012

Document Stores

Document stores are very similar to key value stores, but they allow for embedded structures and a concept of hierarchy

Uses

Content Management Systems(CMS) / Blogging Platforms
Forms/data with many optional fields
Frequently Changing Schemas

Examples

CouchDB
RavenDB
DynamoDB^*
Azure DocumentDB
MongoDB

Considerations

Complex transactions across documents
Complex searching

especially if searching is within the embedded structures

Libraries & Plugins

		Status
	GMongo	Last Updated March 2015
	MongoDB GORM
	CouchDB GORM	Last Updated April 2011
	CouchDB REST API

Column Family

aka Wide Column Stores

Use Cases

CMS Systems/ Blogging Platforms
Log Aggregators
Incremental Counters

Examples

Cassandra
HBase
Hypertable

Considerations

Schema Changes
Arbitrary unstructured data

To Learn More

Grails and Cassandra
http://greachconf.com/speakers/jeff-beck-grails-and-cassandra/
vJUG Cassandra
https://www.youtube.com/watch?v=i3yUlwoCPzU

Graph Databases

Types

Labeled Property Graph
Hypergraphs
Triples

Labeled Property Graph

The figure I used is an example of a Labeled Property Graph. It contains nodes and relationships and each node has properties which can be though of as key-value pairs. The relationships are named and have directionality. This is the most common type of graph database.

Hypergraphs

The second type, a hypergraph, differs mainly by having a relationship connect any number of nodes. This is useful for modeling relationships where multiple nodes (say Alice and Bob) relate to multiple other nodes(say their 3 cars).

Triples

SPARQL

Triple Stores are a semantic way of graphing data in examples that specify a subject, predicate, and then an object.

Uses

Social Networks
E-commerce Recommendations
Geo

Nearby Locations and Routing

Examples

Neo4J
OrientDB
Allegro Graph
Hypergraph DB

Considerations

Deep tree traversals^*
Very different way of thinking about data

Libraries & Plugins

		Status
	Neo4j Native REST API
	Neo4j GORM	Last Updated June 2014

How do I pick just one?

You don't have to!

NoSQL data stores are meant to enhance existing solutions not be a one size fits all solution. Mix and match for various tasks.

Approach # 1

All In - MongoDB GORM

MongoDB

Terminology

Databases
Collections
Document

MongoDB Continued

Created When Needed

Databases
Collections

Optional Fields
BSON Object Ids over Integers

Approach # 2

Partial - Grails-Redis plugin

Redis

Terminology

Keys
Types

String
Hash
Sets

Highlights

Organized/Indexed Keys
CRUD operations
Key Expiration
Service Level Injection rather than all of GORM

Conclusion

Picking a NoSQL solution depends on the problem
Not every tool is the right one for the job
NoSQL stores are valid alternatives to relational databases
NoSQL solutions are highly supported in Groovy and Grails

Questions?

@jennstrater

jenn@gr8ladies.org

No-Nonsense NoSQL

About Me

About Me

About Me

Agenda

What will NOT be covered

Review

Groovy

Grails

New in Grails 3

Relational Databases

Example Task

Code Samples

What is NoSQL?

Goals of NoSQL

CAP Theorem

Types of NoSQL solutions

Key-value Stores

Uses

Examples

Considerations

Libraries & Plugins

Document Stores

Uses

Examples

Considerations

Libraries & Plugins

Column Family

Use Cases

Examples

Considerations

To Learn More

Graph Databases

Types

Labeled Property Graph

Hypergraphs

Triples

Uses

Examples

Considerations

Libraries & Plugins

Suggested Reading

How do I pick just one?

You don't have to!

Approach # 1

MongoDB

MongoDB Continued

Approach # 2

Redis

Highlights

Conclusion

Questions?