**Course Title:** Ruby Programming: From Basics to Advanced Techniques **Section Title:** Working with Databases in Rails **Topic:** Querying the database with ActiveRecord ### Introduction In the previous topic, we explored associations in ActiveRecord. Now, we'll dive into the world of database querying with ActiveRecord. Querying the database is an essential skill for any Rails developer, as it allows you to retrieve and manipulate data in your database. ### Understanding ActiveRecord Queries ActiveRecord provides a powerful and intuitive way of querying your database using Ruby methods. You can think of it as a Domain-Specific Language (DSL) for database queries. #### Retrieving Records Let's start with a simple example of retrieving all records from the `users` table: ```ruby # Retrieves all records from the users table users = User.all ``` You can also use the `find` method to retrieve a single record by its ID: ```ruby # Retrieves a single record by its ID user = User.find(1) ``` #### Filtering Records ActiveRecord provides a variety of methods for filtering records. For example, you can use the `where` method to filter records based on conditions: ```ruby # Retrieves all users with the name 'John' users = User.where(name: 'John') # Retrieves all users with the age greater than 18 users = User.where('age > ?', 18) ``` You can also use the `not` method to negate a condition: ```ruby # Retrieves all users with the name not equal to 'John' users = User.where.not(name: 'John') ``` #### Sorting and Limiting Records You can use the `order` method to sort records: ```ruby # Retrieves all users ordered by name in ascending order users = User.order(:name) # Retrieves all users ordered by age in descending order users = User.order(age: :desc) ``` You can use the `limit` method to limit the number of records retrieved: ```ruby # Retrieves the first 10 users users = User.limit(10) ``` #### Joining Tables ActiveRecord provides several methods for joining tables. For example, you can use the `joins` method to join two tables: ```ruby # Retrieves all users with their corresponding orders users = User.joins(:orders) ``` You can also use the `includes` method to join tables and eager load the associations: ```ruby # Retrieves all users with their corresponding orders users = User.includes(:orders) ``` ### Using SQL Queries Sometimes, you may need to use raw SQL queries to achieve a specific goal. ActiveRecord provides the `execute` method for executing raw SQL queries: ```ruby # Executes a raw SQL query results = ActiveRecord::Base.connection.execute('SELECT * FROM users') ``` ### Best Practices Here are some best practices to keep in mind when using ActiveRecord queries: * Use the `find` method instead of `where` when retrieving a single record by its ID. * Use the `where` method instead of `find_by` when filtering records. * Use the `order` method instead of `sort` when sorting records. * Use the `includes` method instead of `joins` when eager loading associations. ### Conclusion In this topic, we explored the world of database querying with ActiveRecord. We covered retrieving records, filtering records, sorting and limiting records, joining tables, and using raw SQL queries. We also discussed some best practices to keep in mind when using ActiveRecord queries. **Practice Exercise** Try using ActiveRecord queries to retrieve records from a sample database. Experiment with different methods and conditions to filter and sort records. **Resources** * [ActiveRecord Querying Guide](https://guides.rubyonrails.org/active_record_querying.html) * [ActiveRecord API Documentation](https://apidock.com/rails/ActiveRecord) **Leave a comment below with any questions or feedback you may have.** **Next Topic:** Preparing a Rails application for production (Deployment and Best Practices)