NoSQL Benchmarks NoSQL use cases NoSQL Videos NoSQL Hybrid Solutions NoSQL Presentations Big Data Hadoop MapReduce Pig Hive Flume Oozie Sqoop HDFS ZooKeeper Cascading Cascalog BigTable Cassandra HBase Hypertable Couchbase CouchDB MongoDB OrientDB RavenDB Jackrabbit Terrastore Amazon DynamoDB Redis Riak Project Voldemort Tokyo Cabinet Kyoto Cabinet memcached Amazon SimpleDB Datomic MemcacheDB M/DB GT.M Amazon Dynamo Dynomite Mnesia Yahoo! PNUTS/Sherpa Neo4j InfoGrid Sones GraphDB InfiniteGraph AllegroGraph MarkLogic Clustrix CouchDB Case Studies MongoDB Case Studies NoSQL at Adobe NoSQL at Facebook NoSQL at Twitter



grails: All content tagged as grails in NoSQL databases and polyglot persistence

Spring Pet Clinic Goes Grails and Sharded on MongoDB With Cloudify

If you’re a Java programmer you must have heard of the Spring sample app Pet Clinic. To showcase Cloudify, Gigaspaces guys migrated the Pet Clinic to Grails and used MongoDB to shard it:

Grails and MongoDB Pet Clinic

Original title and link: Spring Pet Clinic Goes Grails and Sharded on MongoDB With Cloudify (NoSQL database©myNoSQL)


Grails 2.0 and NoSQL

Graeme Rocher:

Grails 2.0 is the first release of Grails that truly abstracts the GORM layer so that new implementations of GORM can be used. […] The MongoDB plugin is at final release candidate stage and is based on the excellent Spring Data MongoDB project which is also available in RC form. […] Grails users can look forward to more exciting NoSQL announcements in 2012 with upcoming  future releases of GORM for Neo4j, Amazon SimpleDB and Cassandra in the works.

This is great news.

The very very big news would be a Grails version that doesn’t default anymore to using Hibernate for accessing a relational database.

Original title and link: Grails 2.0 and NoSQL (NoSQL database©myNoSQL)


Redis vs H2 Performance in Grails 1.4

I wondered just how much faster read/write operations could be with Redis (if at all) over the H2 database so I set out to write a little test app to see for myself.

It is an apple-to-apple comparison—both Redis and H2 are in-memory databases. But it is not a comparison of Redis vs H2 performance, but rather a comparison of Grails integration for Redis and H2, Grails object to Redis vs object to relational mapping, Redis and H2 drivers, and only at last of Redis and H2 performance.

You could argue that for real applications that’s what matters and that would be correct. But then the title should be the one I used.

Redis vs H2 in Grails 1.4

Original title and link: Redis vs H2 Performance in Grails 1.4 (NoSQL database©myNoSQL)


NoSQL Databases in Grails and Spring Data

When checking the ☞ GitHub repository for Grails/GORM entities support for Riak MapReduce I have noticed multiple NoSQL integration projects[1] :

Grails/GORM and NoSQL databases:

  • Gemfire
  • JCR
  • MongoDB
  • Redis
  • Riak

Spring Data and NoSQL databases:

  • AppEngine
  • Cassandra
  • Gemfire
  • JCR
  • MongoDB
  • Redis
  • Riak

What seems to be missing is the Neo4j support in Spring Data, but maybe there’s a different repo for it.

Finally lots of love for NoSQL database in the Java land.

  1. At this time I’m not sure about each of these project status.  ()

Original title and link: NoSQL Databases in Grails and Spring Data (NoSQL databases © myNoSQL)

Grails/GORM Entities Support for Riak MapReduce

Things are becoming clearer to me: Grails/GORM is the Springframework avant-garde experimenting and integrating various NoSQL databases. Early February there were Grails plugins for CouchDB, HBase, Neo4j, and AppEngine, then it was time for Redis support in Grails, followed shortly by MongoDB support in Grails/GORM.

Over the weekend J.Brisbin added support for Riak MapReduce in Grails/GORM. Project on ☞ GitHub.

Spring Data is the emperor’s army “standardizing” the results.

Original title and link: Grails/GORM Entities Support for Riak MapReduce (NoSQL databases © myNoSQL)

Spring Data: Redis Integration Reaches Milestone 1

The second NoSQL database supported in Spring Data, after Neo4j which was mentioned during the official Spring Data announcement, is, as you’d expect, Redis. Costin Leau just announced the Spring Data - Redis integration first milestone availability.

From the announcement:

  • Connection package as low-level abstraction across multiple drivers
  • Configuration support for Redis Jedis and JRedis drivers/connectors
  • Exception translation to Spring’s portable Data Access exception hierarchy for Redis driver exceptions
  • Generified RedisTemplate for exception translation and serialization support
  • Various serialization strategies
  • Atomic counter support classes
  • JDK Collection implementations on top of Redis

From outside, it is difficult to say if Grails NoSQL integration and Spring Data are correlating their efforts or they just reflect a common strategy with their own efforts. Whatever is the answer, it is quite exciting to start seeing so much NoSQL love in the Java land.

Original title and link: Spring Data: Redis Integration Reaches Milestone 1 (NoSQL databases © myNoSQL)


Grails/GORM for MongoDB

Our crusade to make GORM ubiquitous across NoSQL stores hit another milestones today as we are pleased to announce GORM for MongoDB.

One of the few times I can say that a Java framework is not playing only catch up with Django or Ruby on Rails.

The plugin is available ☞ here.

The new Grails/GORM for MongoDB plugin is ☞ already welcome:

So, it appears that SpringSource have hidden microphones in our office, and the day we were discussing this issue, they came up with this nice news.

Original title and link: Grails/GORM for MongoDB (NoSQL databases © myNoSQL)


Grails and NoSQL with Graeme Rocher and Scott Davis

It is weekend and so it’s time for videos and podcasts. Back in February, I wrote that, at the time, I could count 4 NoSQL plugins for Grails: CouchDB, HBase, Neo4j, AppEngine. In September, Grails added “official” support for Redis. Graeme talked about Grails/GORM for Redis with Jaxenter and community feedback was great.

Embedded below it a conversation between Graeme Rocher and Scott Davis about Grails and NoSQL databases, mentioning Grails support for Redis and Cassandra:

Even if this is great for the Grails and Java community, it doesn’t mean things are simple in the VMWare/Spring/Grails world.

Original title and link: Grails and NoSQL with Graeme Rocher and Scott Davis (NoSQL databases © myNoSQL)

Grails with Redis: Painless NoSQL

Glen Smith trying out Redis support in Grails:

As for the Grails side, you’ll want to “grails uninstall-plugin hibernate”, since I’m using just redis without any other SQL stores. […]

So what other changes did I need to make to store my data in Redis? None! Graeme’s done all the hard work of implement all the basic GORM stuff (including dynamic finders) right into the Redis plugin! Rock on!


So the takeaway from all this is… if you’ve been keen to explore some NoSQL options, there’s never been a better time to have a look at Grails Redis support and dip your toes in the NoSQL waters. Having GORM support makes it insanely easy to experiment with your NoSQL store.

Even if there are ☞ some limitations, it definitely sounds great.

Original title and link: Grails with Redis: Painless NoSQL (NoSQL databases © myNoSQL)


Grails/GORM for Redis Interview

Graeme Rocher (@graemerocher), Grails project lead about Grails support for Redis:

Redis is a key/value store which supports extremely fast read operations so it’s useful in a number of situations where caching solutions have been used, however since Redis supports complex data types like sets, lists and hashes you can also do some more advanced querying compared to other key/value stores. This makes it appropriate for a range of scenarios from sorting data, calculating statistics, queueing jobs or just basic caching. As an example Redis’ set type allows you to store a unique set of values and easily return random entries or pop (remove) entries from a set. Implementing this type of functionality in a performant way on a relational database is typically much harder.

Even if compared with a caching solution, Redis will actually persist your data.

Original title and link for this post: Grails/GORM for Redis Interview (published on the NoSQL blog: myNoSQL)


Redis: Support in Grails Reaches Milestone 1

In February, while reviewing Grails support for NoSQL databases, I’ve listed CouchDB, HBase, Neo4j, and Google AppEngine. But siince then, many things have changed. Redis is now under VMWare’s umbrella too, so today’s announcement of adding support for Redis in Grails should not be a surprise:

What is GORM for Redis? Quite simply it allows Grails developers used to the convenience of features such as dynamic finders, criteria and named queries to take advantage of Redis as their underlying store instead of Hibernate.

In case you are wondering how mapping objects to Redis happens, Graeme Rocher (@graemerocher), Grails project lead, replied:

@al3xandru hashes for entities, sets for associations and indices, set operations for querying. Simple really :-)


Original title and link for this post: Redis: Support in Grails Reaches Milestone 1 (published on the NoSQL blog: myNoSQL)


Grails and NoSQL

Grails is probably one of the most flexible and productive frameworks that runs on the Java VM. One of the most appreciated aspects of Grails is its object relational mapping known as GORM, but lately I have also noticed some NoSQL plugins that I’m listing here (note: please let me know if I’ve missed any):

Unfortunately it was difficult to figure out the status of these plugins only based on their extremely scarce documentation pages. Anyway I really hope to see more activity in this direction as this would definitely help with NoSQL adoption in the more “enterprisey” world.