Skip to main content

Persistence

CouchbaseOrm provides a simple and intuitive way to persist data to Couchbase Server. With CouchbaseOrm, you can easily create, update, save, and destroy records using a set of built-in methods.

5.1. Creating Records

To create a new record, you can instantiate a new instance of your model class and then call the save method to persist it to the database.

class Task < CouchbaseOrm::Base
attribute :title, :string
attribute :description, :string
attribute :completed, :boolean, default: false
end

task = Task.new(title: 'Task 1', description: 'Description of Task 1')
task.save

Alternatively, you can use the create method to create a new record in a single step:

task = Task.create(title: 'Task 1', description: 'Description of Task 1')

The create method instantiates a new instance of the model, sets the attributes, and saves it to the database.

5.2. Saving Records

The save method is used to persist a record to the database, whether it's a new record or an existing one with modifications.

# Update an existing task
task = Task.create(title: 'Task 2', description: 'Description of Task 2')
task.description = 'Updated description of Task 2'
task.save

If the record is new (i.e., it doesn't have an ID), save will create a new document in Couchbase Server. If the record already exists, save will update the existing document with the modified attributes.

5.3. Updating Records

To update an existing record, you can modify its attributes and then call the save method to persist the changes.

# Update specific fields of a task
task = Task.create(title: 'Task 3', description: 'Description of Task 3')
task.update(description: 'Updated description of Task 3', completed: true)

CouchbaseOrm automatically tracks the changes made to the attributes and updates only the modified fields in the database.

5.4. Destroying Records

To delete a record from the database, you can call the destroy method on an instance of your model.

user = User.find('user_id_123')
user.destroy

The destroy method removes the corresponding document from Couchbase Server and freezes the model instance to prevent further modifications.

5.5. Callbacks

As mentioned in the previous section on defining models, CouchbaseOrm supports lifecycle callbacks that allow you to execute code at certain points in a record's persistence lifecycle.

Callbacks can be used to perform actions before or after specific events, such as saving or updating a record. Some commonly used callbacks include before_save, after_save, before_create, after_create, before_update, after_update, before_destroy, and after_destroy.

class User < CouchbaseOrm::Base
before_save :encrypt_password
after_create :send_welcome_email

private

def encrypt_password
self.password = encrypt(password) if password_changed?
end

def send_welcome_email
UserMailer.welcome_email(self).deliver_now
end
end

In this example, the encrypt_password callback is executed before saving a user record, encrypting the password if it has been changed. The send_welcome_email callback is executed after creating a new user record, sending a welcome email to the user.

Callbacks provide a way to encapsulate and reuse common logic related to the persistence lifecycle of your records.