**Course Title:** Mastering Ruby on Rails: Building Scalable Web Applications **Section Title:** Advanced Active Record and Querying **Topic:** Implementing soft deletes and versioning in models **Introduction:** In this topic, we will explore two advanced features of Active Record: soft deletes and versioning. These features allow you to manage data more effectively, especially in scenarios where data is frequently updated or deleted. By the end of this topic, you will be able to implement soft deletes and versioning in your models and understand how to use them to improve your application's scalability and maintainability. **What are Soft Deletes?** Soft deletes are a technique used to mark records as deleted without actually removing them from the database. This approach is useful when you need to keep a record of deleted data, such as when auditing or logging changes to your application. In Rails, you can implement soft deletes using the `destroy` method, which sets the `deleted_at` attribute to the current timestamp. This attribute is not included in the default database schema, so you need to add it manually. **Example:** ```ruby class User < ApplicationRecord # Add the deleted_at attribute to the model timestamps :deleted_at # Implement soft delete by overriding the destroy method def destroy update(deleted_at: Time.current) end end ``` **What are Versioning?** Versioning is a technique used to track changes to your data over time. This approach is useful when you need to maintain a record of changes made to your data, such as when auditing or logging changes to your application. In Rails, you can implement versioning using the `versioning` gem or by adding a `version` attribute to your model. **Example:** ```ruby class User < ApplicationRecord # Add the version attribute to the model version # Implement versioning by overriding the update method def update(attributes) # Update the version attribute update(version: attributes[:version] || version + 1) super(attributes) end end ``` **Using Soft Deletes and Versioning Together** You can use soft deletes and versioning together to create a powerful data management system. For example, you can use soft deletes to mark records as deleted and versioning to track changes made to the record before it was deleted. **Example:** ```ruby class User < ApplicationRecord # Add the deleted_at attribute to the model timestamps :deleted_at # Add the version attribute to the model version # Implement soft delete by overriding the destroy method def destroy update(deleted_at: Time.current) end # Implement versioning by overriding the update method def update(attributes) # Update the version attribute update(version: attributes[:version] || version + 1) super(attributes) end end ``` **Practical Takeaways:** 1. Use soft deletes to manage data that is frequently updated or deleted. 2. Use versioning to track changes made to your data over time. 3. Use soft deletes and versioning together to create a powerful data management system. 4. Consider using the `versioning` gem to implement versioning in your models. **Additional Resources:** * Rails API: [ActiveRecord::Base#timestamps](https://api.rubyonrails.org/v6.1.4/classes/ActiveRecord::Base.html#method-itimestamps) * Rails API: [ActiveRecord::Base#destroy](https://api.rubyonrails.org/v6.1.4/classes/ActiveRecord::Base.html#method-idestroy) * Rails API: [ActiveRecord::Base#update](https://api.rubyonrails.org/v6.1.4/classes/ActiveRecord::Base.html#method-iupdate) * Rails API: [ActiveRecord::Base#version](https://api.rubyonrails.org/v6.1.4/classes/ActiveRecord::Base.html#method-iversion) * Rails API: [ActiveRecord::Base#timestamps](https://api.rubyonrails.org/v6.1.4/classes/ActiveRecord::Base.html#method-itimestamps) **Leave a comment or ask for help:**