In our last video, we learned how to use Active Record’s create and save commands to insert records into our tables. We saw how these generate generic SQL queries, wrap them in transactions to ensure data integrity, and provide error-handling mechanisms using the exclamation point (!) or its absence.

In this video, I want to explore how Active Record handles errors, what actually happens behind the scenes, and how we can control these behaviors.

Exploring Error Handling in Active Record

Jumping into our IRB playground session, I’ve added more details to our Post model:

1. A validation rule – The title field must be present.
2. A callback – After a successful create operation, a message will print confirming that the callback was triggered.

Let’s get this set up and explore edge cases in how create and save handle errors.

What Happens When We Try to Create an Invalid Record?

Instead of supplying values, let’s try creating an empty record:

post = Post.create!

This raises an exception with a long stack trace with a validation error:

Validation failed: Title can't be blank (ActiveRecord::RecordInvalid)

We also notice that no SQL queries are executed. This confirms that Active Record stops execution if validations fail, preventing invalid data from reaching the database.

Using create Without the Bang (!)

Now, let’s try creating a record without the exclamation point:

post = Post.create

Again, no SQL queries are executed, but this time, instead of raising an exception, we get back a blank Post object.

Checking post.errors reveals:

post.errors
# => [#<ActiveModel::Error attribute=title, type=blank, options={}]>

With both the create and save method, it is always going to first run the validations defined on the Active Record Model.

If a record fails validation, it is halted and no SQL queries are executed. Instead either the bang (!) version raises an exception or the non-bang version returns a non-persisted object with validation errors.

In summary, you can:

• Use create! or save! when you want to force valid data and get an immediate error if something is wrong.
• Use create or save when you want to handle errors manually and check .errors.

Understanding Callbacks in Active Record

So far, we haven’t seen our callback message print. That’s because the record hasn’t been created successfully.

Now, let’s create a valid record:

Post.create!(title: "new title")

This time, we see:

1. A SQL INSERT statement is executed.
2. A transaction is committed.
3. The callback message is printed, confirming the callback ran after the record was saved.

Key Takeaways from create and save

• Validations run before executing SQL queries.
• Callbacks only run after a successful database transaction.
• Using create! or save! throws an exception on failure, while create or save returns an object with errors.

In the next video, we’ll explore how to insert records directly into the database without triggering validations or callbacks—a technique that can be useful for performance-sensitive operations.