Beyond SQL: A New Ruby ORM for Adaptive Data

A practical guide for Ruby applications

Ruby remains one of the most popular choices for building scalable applications, and Ruby on Rails continues to be one of the most flexible and robust web frameworks available. Notwithstanding the developer ease with working with Ruby and Ruby on Rails, managing the complexities of data operations can still be challenging, especially when dealing with adaptive and flexible data in non-relational databases like Couchbase. This no longer needs to be challenging though, as there is now the newly released Couchbase Ruby ORM.

The Couchbase Ruby ORM is a tool designed to simplify database interactions and streamline your development process. The Couchbase open source community started this project through the great work of developers at Doctolib, Mapotempo and others. Now, the project has officially been adopted as part of the Couchbase developer tooling ecosystem.

In this post, we’ll explore how the ORM can enhance your applications.

tl;dr You can find an entire working Rails application using the new Couchbase Ruby ORM on GitHub

Let’s get started!

The power of ORMs

Object Relational Mappers (ORMs) are a fundamental staple in modern web development. They allow developers to interact with a database using objects rather than writing raw database queries. In the case of Ruby applications, that means working with your data as if it were Ruby objects. This abstraction not only simplifies the overall codebase, but enhances readability and maintainability.

Within the context of Couchbase, an ORM is particularly beneficial because it bridges the gap between its document-based storage and the object-oriented nature of Ruby. By using the new Couchbase Ruby ORM, you can leverage many of Couchbase’s features while maintaining the familiar Ruby development experience that we all enjoy.

Benefits of using a Ruby ORM in your applications

If you are a Ruby on Rails developer, you are well familiar with the benefits of using ActiveRecord, Rails’ built-in ORM, to manage your data. However, it bears repeating what those benefits precisely are. They can be summarized into four key points:

1. Ease of Use: Once you can define your data models as Ruby classes and attributes, you make your codebase more intuitive and easier to navigate.
2. Data Integrity: Automatically handling data validations and constraints at the model level ensures your data stays the way you intended it to stay. No need to add an additional layer of validation on your data, in more server side middleware or on the client, once the data is being validated directly in the model.
3. Enhanced Productivity: Reduce your boilerplate code, allowing you to focus on the business logic rather than getting carried away with database management in your application.
4. Consistency: Standardize data access patterns across your application, and by doing so, make your future self and your colleagues happier when you, or they, need to come back and refactor the application weeks or months later.

With the new Couchbase Ruby ORM you can extend all those benefits to your data on Couchbase, providing a seamless integration between your application and your flexible and adaptive data. In a Rails application context, the ORM extends ActiveRecord functionality, enabling Rails developers to work with Couchbase data using all their familiar methods and conventions.

A practical example

Let’s consider a fictional blogging platform. This platform needs to manage user profiles, comments, tags and content efficiently. The platform manages all sorts of content with different types of data, which is why building with a JSON document database like Couchbase is the way to go.

How would that look in reality?

Defining models with the Couchbase ORM

Let’s start with an Article model:

class Article < CouchbaseOrm::Base
  attribute :slug, :string
  attribute :title, :string
  attribute :description, :string
  attribute :body, :string
  attribute :tag_list, :string
  attribute :created_at, :time
  attribute :updated_at, :time
  attribute :author_id, :string
  attribute :favorites
  attribute :favorites_count, :integer, default: 0

  view :by_id, emit_key: :id
  view :by_slug, emit_key: :slug
  view :by_author_id, emit_key: :author_id
  view :by_article_id, emit_key: :id

  validates :slug, presence: true
  validates :title, presence: true
  validates :description, presence: true
  validates :body, presence: true
  validates :tag_list, presence: true
  validates :author_id, presence: true
end

This model defines an article with various attributes, leveraging Couchbase’s ability to handle diverse data types. The attributes are defined similarly to how they would be in any ActiveRecord usage, making it easy for Ruby developers, and Rails developers in particular, to adopt it.

The view statements shown above establish defined ways to query documents stored in Couchbase. Each view is essentially an index that allows you query documents by a specific attribute more efficiently. For example, the view :by:slug, emit_key :slug statement creates a view that indexes articles by their slug attribute. This view allows you to retrieve articles based on their slug.

Defining associations with the Couchbase ORM

Now, what about associations of data in the blogging platform? The blogging platform needs to ensure that each comment belongs to a specific user and to a specific article. The same way that can be done in a standard Rails model, is how it can be done using the Couchbase Ruby ORM. Here’s how that can be set up:

class Comment < CouchbaseOrm::Base
  belongs_to :user
  belongs_to :article
end

With those associations, comments belong to both a user and an article. Similarly, you can also define a dependent relationship in the model, too. Take a look again at the Article class to see this in action:

class Article < CouchbaseOrm::Base
  belongs_to :user
  has_many :comments, dependent: :destroy
end

The same way that we demonstrated creating attributes on data models and defining associations, the ORM similarly provides functionality for querying, creating custom SQL++ queries, working with nested documents and a lot more. The documentation provides a rich array of example code for all the possible scenarios you may need to work with.

Wrapping up

The new Couchbase Ruby ORM brings powerful and flexible database management to Ruby, and to Ruby on Rails applications. By abstracting any of the complexities of Couchbase’s document-oriented design, it enables developers to build scalable and maintainable applications with ease. No matter what the nature of the application is, from an ecommerce platform to a blogging content management system, the Couchbase ORM offers a robust solution for integrating Couchbase within your Ruby stack.

Try it out yourself and experience the benefits!

• Couchbase Ruby ORM tutorial on GitHub
• Use Couchbase Capella DBaaS for free