couchbase-orm 2.0.4 → 2.0.5

data/docusaurus/docs/tutorial-ruby-couchbase-orm/04-querying.md

@@ -0,0 +1,154 @@
+# Querying
+
+CouchbaseOrm provides a powerful and expressive query interface for retrieving data from Couchbase Server. With CouchbaseOrm, you can easily construct queries using a fluent and intuitive API that resembles the querying capabilities of ActiveRecord.
+
+## 4.1. Finding Records
+
+CouchbaseOrm offers various methods to find records based on different criteria. Here are some commonly used methods:
+
+- `find`: Finds a record by its primary key (ID).
+- `find_by`: Finds the first record that matches the specified attribute-value pair.
+- `where`: Retrieves records that match the specified conditions.
+
+Here are some examples of finding records:
+
+```ruby
+# Define an Author model
+class Author < CouchbaseOrm::Base
+  attribute :name, :string
+  attribute :age, :integer
+  attribute :active, :boolean, default: true
+
+  validates :name, presence: true
+  validates :age, numericality: { greater_than_or_equal_to: 18 }
+
+end
+
+# Create new authors
+author1 = Author.new(name: 'John Doe', age: 30, active: true)
+author2 = Author.new(name: 'Jane Smith', age: 25, active: false)
+author3 = Author.new(name: 'Alice Brown', age: 40, active: true)
+author4 = Author.new(name: 'Bob Johnson', age: 17, active: true)
+
+# Save authors
+author1.save
+author2.save
+author3.save
+author4.save
+
+# Find authors by ID
+puts Author.find(author1.id).inspect
+
+# Find the first author with a specific name
+puts Author.find_by(name: 'John Doe').inspect
+
+# Where
+puts Author.where(active: true).to_a.inspect
+```
+
+## 4.2. Where Clauses
+
+The `where` method allows you to specify conditions to filter the records based on attribute values. You can chain multiple `where` clauses together to build more complex queries.
+
+```ruby
+# Where
+puts Author.where(active: true).where('age >= 30').to_a.inspect
+
+puts Author.where("name like '%John%'").to_a.inspect
+```
+
+CouchbaseOrm supports various comparison operators and placeholders in the `where` clauses, such as `=`, `>`, `<`, `>=`, `<=`, `LIKE`, and more.
+
+## 4.3. Ordering
+
+You can specify the order in which the retrieved records should be sorted using the `order` method. Pass the attribute name and the desired sort direction (`:asc` for ascending, `:desc` for descending).
+
+```ruby
+# Order authors by name
+puts Author.order(:name).to_a.inspect
+
+# Order authors by age in descending order
+puts Author.order(age: :desc).to_a.inspect
+```
+
+You can also chain multiple `order` clauses to sort by multiple attributes.
+
+
+Scopes provide a clean and DRY way to encapsulate commonly used query conditions.
+
+## 4.4. Pluck
+
+The `pluck` method allows you to retrieve specific attributes from the matched records instead of loading the entire objects. It returns an array of values for the specified attributes.
+
+```ruby
+# Pluck names of all authors
+puts Author.order(:name).pluck(:name).inspect
+```
+
+## 4.5. Destroying Records
+
+To delete multiple records that match specific conditions, you can use the `.each(&:destroy)` method. It deletes the records from the database and returns the number of records deleted.
+
+- `:destroy`: Deletes a single record.
+- `delete_all`: Deletes all records that match the specified conditions.
+
+```ruby
+# Destroy all inactive authors
+Author.where(active: false).each(&:destroy)
+
+# Destroy all authors who are inactive
+Author.where(active: false).delete_all
+
+```
+
+
+These are just a few examples of the querying capabilities provided by CouchbaseOrm. You can combine these methods in various ways to construct complex and specific queries based on your application's requirements.
+
+In the next section, we'll explore how to use CouchbaseOrm to create, update, and delete records in Couchbase Server.
+
+## 4.6. Scopes
+
+Scopes allow you to define reusable query snippets that can be chained with other query methods. Scopes are defined as class methods within your model.
+
+```ruby
+# Define a Comment model
+class Comment < CouchbaseOrm::Base
+  attribute :title, :string
+  attribute :author, :string
+  attribute :category, :string
+  attribute :ratings, :integer
+
+  def self.by_author(author)
+    where(author: author)
+  end
+
+  def self.highly_rated
+    where('ratings > 3')
+  end
+
+  def self.in_category(category)
+    where(category: category)
+  end
+end
+
+
+# Create some comments
+comment1 = Comment.new(title: 'First Comment', author: 'Anne McCaffrey', category: 'S-F', ratings: 5)
+comment2 = Comment.new(title: 'Second Comment', author: 'Anne McCaffrey', category: 'S-F', ratings: 4)
+comment3 = Comment.new(title: 'Third Comment', author: 'Anne McCaffrey', category: 'S-F', ratings: 3)
+comment4 = Comment.new(title: 'Fourth Comment', author: 'Anne McCaffrey', category: 'S-F', ratings: 2)
+
+# Save the comments
+comment1.save
+comment2.save
+comment3.save
+comment4.save
+
+# Example usage of scopes
+comments = Comment.by_author("Anne McCaffrey").in_category('S-F').highly_rated.order(:title).limit(10)
+
+# Iterate over the comments
+comments.each do |comment|
+  puts "Title: #{comment.title}, Author: #{comment.author}, Category: #{comment.category}, Ratings: #{comment.ratings}"
+end
+```

data/docusaurus/docs/tutorial-ruby-couchbase-orm/05-persistence.md

@@ -0,0 +1,93 @@
+# 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.
+
+```ruby
+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:
+
+```ruby
+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.
+
+```ruby
+# 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.
+
+```ruby
+# 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.
+
+```ruby
+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`.
+
+```ruby
+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.

data/docusaurus/docs/tutorial-ruby-couchbase-orm/06-associations-and-validations.md

@@ -0,0 +1,236 @@
+# Associations and Validations
+
+## 6. Associations
+
+CouchbaseOrm provides a way to define and work with associations between models. Associations allow you to establish relationships between different entities in your application, making it easier to manage and query related data.
+
+CouchbaseOrm supports several types of associations, including:
+
+- One-to-One (belongs_to)
+- One-to-Many (has_many)
+- Many-to-Many (has_and_belongs_to_many)
+
+## 6.1. Belongs To
+
+The `belongs_to` association is used to define a one-to-one relationship between two models, where the model containing the association "belongs to" the other model.
+
+In the belongs to, `class_name` is the name of the class that the association points to. `foreign_key` is the name of the field in the current model that references the associated model.
+
+They are optional and will be inferred from the association name if not provided.
+
+Class name follows Pascal case and foreign key follows snake case.
+
+```ruby
+class Teacher < CouchbaseOrm::Base
+ ...
+end
+class Student < CouchbaseOrm::Base
+  attribute :name, :string
+  attribute :grade, :integer
+  attribute :teacher_id, :string
+
+  belongs_to :teacher, class_name: 'Teacher', foreign_key: :teacher_id
+
+  validates_presence_of :name, :grade, :teacher_id
+end
+
+```
+
+In this example, a `Student` belongs to a `Teacher`. CouchbaseOrm assumes that the `students` documents contain a `teacher_id` field that references the associated teacher document.
+
+
+## 6.2. Has Many
+
+The `has_many` association is used to define a one-to-many relationship between two models, where one model can have multiple associated records of another model.
+
+```ruby
+class Teacher < CouchbaseOrm::Base
+  attribute :name, :string
+  attribute :subject, :string
+
+  has_many :students, class_name: 'Student', foreign_key: :teacher_id, type: :n1ql, dependent: :destroy
+
+  validates_presence_of :name, :subject
+end
+
+class Student < CouchbaseOrm::Base
+ ...
+end
+
+```
+
+In this example, a `Teacher` has many `Student`s, and a `Student` belongs to a `Teacher`. CouchbaseOrm assumes that the `students` documents contain a `teacher_id` field that references the associated teacher document.
+
+The class name and foreign key are optional and will be inferred from the association name if not provided.
+
+In the following example, we demonstrate how to work with associations in CouchbaseOrm:
+
+```ruby
+# Creating a new teacher
+teacher1 = Teacher.create(name: 'Mr. Smith', subject: 'Mathematics')
+
+# Creating new students
+student1 = Student.create(name: 'John Doe', grade: 9, teacher_id: teacher1.id)
+student2 = Student.create(name: 'Jane Roe', grade: 10, teacher_id: teacher1.id)
+
+# Associating students with teacher
+puts "Teacher's students: #{teacher1.students.inspect}"
+
+# Find a teacher by a student's teacher_id
+found_teacher = Teacher.find(student1.teacher_id)
+puts found_teacher.inspect
+
+# List students of a teacher
+teacher1.reload
+teacher_students = teacher1.students
+teacher_students.each { |student| puts student.inspect }
+```
+
+## 6.3. Has And Belongs To Many
+
+The `has_and_belongs_to_many` association is used to define a many-to-many relationship between two models, where each model can have multiple associated records of the other model.
+
+```ruby
+class Publisher < CouchbaseOrm::Base
+  attribute :name, :string
+  has_and_belongs_to_many :magazines, join_class: 'PublishersMagazines'
+
+  validates :name, presence: true
+end
+
+class Magazine < CouchbaseOrm::Base
+  attribute :title, :string
+  attribute :genre, :string
+  has_and_belongs_to_many :publishers, join_class: 'PublishersMagazines'
+
+  validates :title, presence: true
+  validates :genre, presence: true
+end
+
+class PublishersMagazines < CouchbaseOrm::Base
+  attribute :publisher_id, :string
+  attribute :magazine_id, :string
+
+  validates :publisher_id, presence: true
+  validates :magazine_id, presence: true
+end
+
+```
+
+In this example, a `Publisher` has and belongs to many `Magazine`s, and a `Magazine` has and belongs to many `Publisher`s. The `PublishersMagazines` class serves as the join class that connects the `Publisher` and `Magazine` models.
+
+You can customize the association name, class name, and foreign key if needed:
+
+```ruby
+class Publisher < CouchbaseOrm::Base
+  has_and_belongs_to_many :books, class_name: 'Book', join_table: 'publishers_books', foreign_key: 'publisher_id', association_foreign_key: 'book_id'
+end
+```
+
+In the following example, we demonstrate how to work with many-to-many associations in CouchbaseOrm:
+
+```ruby
+# Create magazines
+magazine1 = Magazine.create(title: 'Vogue', genre: 'Fashion')
+magazine2 = Magazine.create(title: 'National Geographic', genre: 'Science')
+
+# Create publishers
+publisher1 = Publisher.create(name: 'Penguin Random House')
+publisher2 = Publisher.create(name: 'Hearst Communications')
+
+# Associate publishers with magazines
+publisher1.magazines = [magazine1, magazine2]
+publisher2.magazines = [magazine1]
+publisher1.save
+publisher2.save
+
+magazine1.publishers = [publisher1, publisher2]
+magazine2.publishers = [publisher1]
+magazine1.save
+magazine2.save
+
+# Print publishers and their magazines
+puts Publisher.all.map { |publisher| "#{publisher.name} (ID: #{publisher.id})" }
+
+# Print magazines and their publishers 
+puts Magazine.all.map { |magazine| "#{magazine.title} (Genre: #{magazine.genre}) by #{magazine.publishers.map(&:name).join(', ')} (ID: #{magazine.id})" }
+
+# print magazine and tojson
+puts Magazine.all.map { |magazine| "#{magazine.to_json}" }
+```
+
+## 6.4. Polymorphic Associations
+
+CouchbaseOrm supports polymorphic associations, which allow a model to belong to multiple other models through a single association.
+
+```ruby
+class Comment < CouchbaseOrm::Base
+  belongs_to :commentable, polymorphic: true
+end
+
+class Post < CouchbaseOrm::Base
+  has_many :comments, as: :commentable
+end
+
+class Photo < CouchbaseOrm::Base
+  has_many :comments, as: :commentable
+end
+```
+
+In this example, a `Comment` can belong to either a `Post` or a `Photo` through the `commentable` association. The `commentable_type` field in the `comments` document stores the type of the associated record (`Post` or `Photo`), and the `commentable_id` field stores the ID of the associated record.
+
+## 6.5. Dependent Associations
+
+CouchbaseOrm allows you to specify what should happen to associated records when the parent record is destroyed. You can use the `dependent` option to control this behavior.
+
+```ruby
+class User < CouchbaseOrm::Base
+  has_many :posts, dependent: :destroy
+end
+```
+
+In this example, when a `User` is destroyed, all associated `Post`s will also be destroyed. Other options for `dependent` include `:nullify` (sets the foreign key to null), `:restrict_with_exception` (raises an exception if there are associated records), and `:delete_all` (deletes associated records without running callbacks).
+
+## 6.6. Autosave
+
+CouchbaseOrm provides an `autosave` option that automatically saves associated records when saving the parent record.
+
+```ruby
+class User < CouchbaseOrm::Base
+  has_many :posts, autosave: true
+end
+```
+
+With `autosave` set to `true`, saving a `User` will also save any new or modified associated `Post`s.
+
+## 6.7. Querying Associations
+
+CouchbaseOrm allows you to easily query and retrieve associated records using the defined associations.
+
+```ruby
+user = User.find('user_id_123')
+posts = user.posts
+```
+
+In this example, `user.posts` retrieves all the associated `Post`s for the given `User`.
+
+You can also chain query methods on associations:
+
+```ruby
+recent_posts = user.posts.where('created_at >= ?', 1.week.ago).order(created_at: :desc)
+```
+
+This query retrieves the associated `Post`s for the user that were created within the last week, ordered by the most recent first.
+
+
+<!-- ## 6.9. Strict Loading
+
+CouchbaseOrm provides a `strict_loading` option that allows you to control how associations are loaded. When `strict_loading` is enabled, associations are loaded eagerly when the parent record is loaded, reducing the number of queries needed to fetch associated records.
+
+```ruby
+class User < CouchbaseOrm::Base
+  has_many :posts, strict_loading: true
+end
+``` -->
+
+Now, let's move on to the next section, where we'll explore how to use N1QL queries in CouchbaseOrm for more advanced querying capabilities.

data/docusaurus/docs/tutorial-ruby-couchbase-orm/07-sqlpp-queries.md

@@ -0,0 +1,180 @@
+# SQL++ (formerly N1QL) Queries 
+
+CouchbaseOrm provides support for executing SQL++ queries directly from your Ruby code. SQL++ (or formerly N1QL,i.e. Non-First Normal Form Query Language) is a powerful query language that allows you to perform complex queries and aggregations on your Couchbase data.
+
+## 7.1 Defining SQL++ Queries
+
+To define an SQL++ query in your model, you can use the `n1ql` macro provided by CouchbaseOrm. Here are a few examples:
+
+```ruby
+class N1QLTest < CouchbaseOrm::Base
+  attribute :name, type: String
+  attribute :lastname, type: String
+  enum rating: %i[awesome good okay bad], default: :okay
+  attribute :country, type: String
+
+  # Example 1: Custom query with specific rating values
+  n1ql :by_custom_rating, emit_key: [:rating], query_fn: proc { |bucket, _values, options|
+    cluster.query("SELECT raw meta().id FROM `#{bucket.name}` WHERE type = 'n1_ql_test' AND rating IN [1, 2] ORDER BY name ASC", options)
+  }
+
+  # Example 2: Simple query by name
+  n1ql :by_name, emit_key: [:name]
+
+  # Example 3: Simple query by lastname
+  n1ql :by_lastname, emit_key: [:lastname]
+
+  # Example 4: Custom query by country with parameter binding
+  n1ql :by_country, emit_key: [:country], query_fn: proc { |bucket, values, options|
+    cluster.query(
+      "SELECT raw meta().id FROM `#{bucket.name}` WHERE type = 'n1_ql_test' AND country = $country ORDER BY name ASC",
+      Couchbase::Options::Query(named_parameters: { country: values[0] })
+    )
+  }
+
+  # Example 5: Simple query by rating
+  n1ql :by_rating_emit, emit_key: :rating
+
+  # Example 6: Custom query by rating with parameter binding
+  n1ql :by_custom_rating_values, emit_key: [:rating], query_fn: proc { |bucket, values, options|
+    cluster.query("SELECT raw meta().id FROM `#{bucket.name}` where type = 'n1_ql_test' AND rating IN #{quote(values[0])} ORDER BY name ASC", options)
+  }
+
+  # Example 7: Custom query by rating with custom ordering
+  n1ql :by_rating_reverse, emit_key: :rating, custom_order: 'name DESC'
+
+  # Example 8: Simple query by rating without including documents
+  n1ql :by_rating_without_docs, emit_key: :rating, include_docs: false
+
+  # Index definition for the rating attribute
+  index_n1ql :rating
+end
+
+```
+
+In these examples:
+
+- The `by_custom_rating` query selects the document IDs where the type is 'n1_ql_test' and the rating is either 1 or 2, ordered by the name attribute in ascending order.
+
+- The `by_name`, `by_lastname`, and `by_rating_emit` queries use the emit_key option to specify the attribute to be used as the key for the query.
+
+- The `by_custom_rating_values` query demonstrates passing values to the query using placeholders ($1, $2, etc.) and the quote method to properly escape the values.
+
+- The `by_rating_reverse` query uses the custom_order option to specify a custom ordering for the query results.
+
+- The `by_rating_without_docs` query sets include_docs to false to retrieve only the document IDs without fetching the full documents.
+
+- The `index_n1ql` macro is used to define an index on the rating attribute and generate a corresponding query method. Note that the index_n1ql macro does not create the index in the Couchbase Dashboard directly; you would need to create the index separately using the Couchbase Dashboard or the Couchbase Query UI.
+
+## 7.2 Query Parameters
+
+SQL++ queries often require parameters to be passed in order to filter or customize the results. CouchbaseOrm allows you to define queries with placeholders and provide the parameter values when executing the query.
+
+```ruby
+n1ql :by_custom_rating_values, emit_key: [:rating], query_fn: proc { |bucket, values, options|
+  cluster.query("SELECT raw meta().id FROM `#{bucket.name}` where type = 'n1_ql_test' AND rating IN #{quote(values[0])} ORDER BY name ASC", options)
+}
+```
+
+In this example, the `values` parameter represents an array of values passed to the query. The `quote` method is used to properly escape and format the values for use in the query.
+
+## 7.3 Executing SQL++ Queries
+
+To execute an SQL++ query, you simply call the defined query method on your model class.
+
+```ruby
+docs = N1QLTest.by_custom_rating().collect { |ob| ob.name }
+```
+
+CouchbaseOrm automatically executes the SQL++ query and returns the result set, which you can then process as needed.
+
+## 7.4 Query Options
+
+CouchbaseOrm provides various options to customize the execution of SQL++ queries. These options can be passed as a hash parameter to the query method.
+
+```ruby
+docs = N1QLTest.by_rating_reverse(key: 1)
+```
+
+<!-- Some commonly used query options include:
+
+- `key`: Specifies the key value(s) to filter the results.
+- `limit`: Specifies the maximum number of results to return.
+- `offset`: Specifies the number of results to skip before starting to return results.
+- `include_docs`: Specifies whether to include the full document content in the results.
+- `scan_consistency`: Specifies the consistency level for the query (`request_plus` by default). -->
+
+## 7.5 Placeholder Values
+
+You can use placeholder values in your SQL++ queries and pass the actual values when executing the query.
+
+```ruby
+ n1ql :by_country, emit_key: [:country], query_fn: proc { |bucket, values, options|
+    cluster.query(
+      "SELECT raw meta().id FROM `#{bucket.name}` WHERE type = 'n1_ql_test' AND country = $country ORDER BY name ASC",
+      Couchbase::Options::Query(named_parameters: { country: values[0] })
+    )
+  }
+
+docs = N1QLTest.by_country(key: 'USA').collect { |ob| ob.name }
+```
+
+In this example, the `by_country` query uses a placeholder `$country` in the query string and passes the actual value `'USA'` as the parameter value when executing the query.
+
+## 7.6 Query Result Processing
+
+By default, CouchbaseOrm automatically maps the query result to instances of your model class. However, you can also process the query result manually if needed.
+
+```ruby
+n1ql :by_custom_rating, emit_key: [:rating], query_fn: proc { |bucket, _values, options|
+  cluster.query("SELECT raw meta().id FROM `#{bucket.name}` WHERE type = 'n1_ql_test' AND rating IN [1, 2] ORDER BY name ASC", options)
+}
+
+n1ql :by_custom_rating_values, emit_key: [:rating], query_fn: proc { |bucket, values, options|
+  cluster.query("SELECT raw meta().id FROM `#{bucket.name}` where type = 'n1_ql_test' AND rating IN #{quote(values[0])} ORDER BY name ASC", options)
+}
+```
+
+In the above example, the `by_custom_rating` and `by_custom_rating_values` queries are executed, and the results are processed manually to extract the `name` attribute from each document.
+
+```ruby
+# Query by custom rating
+docs = N1QLTest.by_custom_rating.collect { |ob| ob.name }
+
+# Query by custom rating values
+docs = N1QLTest.by_custom_rating_values(key: [[1, 2]]).collect { |ob| ob.name }
+```
+
+In the above examples, the `collect` method is used to extract the `name` attribute from each document in the result set.
+
+## 7.7 Indexing for SQL++
+
+To optimize the performance of SQL++ queries, it's important to create appropriate indexes on the fields used in the query conditions. Couchbase Server provides a way to create indexes using the Index service.
+
+```ruby
+
+class N1QLTest < CouchbaseOrm::Base
+  ... 
+
+  # Index definition for the rating attribute
+  index_n1ql :rating
+end
+
+# Query using index_n1ql
+docs = N1QLTest.find_by_rating(2).collect { |ob| ob.name }
+
+# Query using index_n1ql
+docs = N1QLTest.by_rating.to_a.collect { |ob| ob.name }
+```
+
+In this example, indexes are defined on the `rating` attribute using the `index_n1ql` macro.
+
+Indexing helps improve the efficiency of SQL++ queries by allowing Couchbase Server to quickly locate the relevant documents based on the indexed fields.
+
+---
+
+SQL++ queries in CouchbaseOrm provide a powerful and flexible way to retrieve data from Couchbase Server. By leveraging the expressive power of SQL++, you can perform complex queries, aggregations, and data manipulations directly from your Ruby code.
+
+Remember to ensure that you have the necessary indexes created on the fields used in your queries for optimal performance. Additionally, consider the query consistency level and other options based on your application's requirements.
+
+With CouchbaseOrm's SQL++ support, you can easily integrate advanced querying capabilities into your Ruby application, enabling you to retrieve and manipulate data stored in Couchbase Server efficiently.