**Course Title:** Mastering Ruby on Rails: Building Scalable Web Applications **Section Title:** Advanced Active Record and Querying **Topic:** Implement advanced Active Record features in an application with multiple models and relationships.(Lab topic) **Objective:** By the end of this topic, students will be able to implement advanced Active Record features in a Rails application, including scopes, joins, eager loading, and complex queries. Students will also learn how to optimize performance and apply these features in a real-world scenario. **Importance of Active Record Features:** Active Record is a powerful tool in Rails that provides a simple and intuitive way to interact with your database. However, as your application grows, you may need to perform more complex queries and manipulate data in various ways. This topic will cover some of the advanced features of Active Record that will help you achieve this. **Lab Topic:** In this lab, we will create a simple e-commerce application with multiple models and relationships. We will then implement advanced Active Record features to optimize performance and retrieve data efficiently. **Materials Needed:** * Ruby on Rails 7.0.4 * Rails 7.0.4 gemset * MySQL or PostgreSQL database **Step 1: Setting up the Application** Create a new Rails application using the command `rails new e-commerce_app`. This will create a basic application with the necessary files and directories. ```bash rails new e-commerce_app ``` **Step 2: Defining Models and Relationships** Create three models: `Product`, `Order`, and `Customer`. Each model will have relationships with the other models. ```ruby # app/models/product.rb class Product < ApplicationRecord has_many :orders end # app/models/order.rb class Order < ApplicationRecord belongs_to :customer belongs_to :product end # app/models/customer.rb class Customer < ApplicationRecord has_many :orders end ``` **Step 3: Implementing Scopes** Scopes are a way to define a set of conditions that can be applied to a model. In this example, we will create a scope that retrieves all products that belong to a specific customer. ```ruby # app/models/product.rb class Product < ApplicationRecord scope :by_customer, ->(customer) { where(customer_id: customer.id) } end ``` **Step 4: Implementing Joins** Joins are a way to combine data from multiple models. In this example, we will create a join that retrieves all orders and products for a specific customer. ```ruby # app/models/order.rb class Order < ApplicationRecord def self.with_products(customer) joins(:product).where(customer_id: customer.id) end end ``` **Step 5: Implementing Eager Loading** Eager loading is a way to load related data in a single query. In this example, we will create a method that retrieves all orders and products for a specific customer, eager loading the products. ```ruby # app/models/customer.rb class Customer < ApplicationRecord def self.with_orders_and_products includes(:orders, :products) end end ``` **Step 6: Implementing Complex Queries** Complex queries are a way to retrieve data from the database using a variety of methods. In this example, we will create a method that retrieves all orders and products for a specific customer, using a complex query. ```ruby # app/models/order.rb class Order < ApplicationRecord def self.with_products_and_total joins(:product).where(customer_id: customer.id).select('orders.*', 'products.name AS product_name', 'orders.total AS total') end end ``` **Step 7: Optimizing Performance** To optimize performance, we can use techniques such as caching and indexing. In this example, we will create a cache store to store frequently accessed data. ```ruby # config/initializers/cache_store.rb Rails.application.config.cache_store = :dalli_store ``` **Conclusion:** In this topic, we covered some of the advanced features of Active Record, including scopes, joins, eager loading, and complex queries. We also learned how to optimize performance using caching and indexing. By applying these features in a real-world scenario, you will be able to build scalable and efficient web applications. **Exercise:** Implement the features covered in this topic in your own Rails application. Create a simple e-commerce application with multiple models and relationships, and then implement scopes, joins, eager loading, and complex queries to optimize performance. **External Resources:** * [Active Record Documentation](https://guides.rubyonrails.org/active_record_overview.html) * [Rails Caching Documentation](https://guides.rubyonrails.org/caching.html) * [Dalli Cache Store Documentation](https://github.com/dalli/dalli) **Leave a comment or ask for help:** If you have any questions or need further clarification on any of the concepts covered in this topic, please leave a comment below.