SQLite is really a good tool to set up quick proof of concepts and small applications; however it’s not the most robust solution on the market for working with relational databases. In the open source community two databases take the top of the list: PostgreSQL and MySQL.
I did a small project for my studies. I was using SQLite as I didn’t need much out of it. Curious, I decided to see how the application would behave on other databases and decided to try PostgreSQL and MySQL. I had two problems to solve, and this post is about the first one: how to deal with the migrations. They were as follows:
Active Record automatically put the field
id in all of its tables, that’s why it is omitted on the migrations.
In PostgreSQL it went smoothly, all the migrations ran without any hiccup, except on MySQL, it gave me an error!
StandardError: An error has occurred, all later migrations canceled: Column `artist_id` on table `songs` has a type of `int(11)`. This does not match column `id` on `artists`, which has type `bigint(20)`. To resolve this issue, change the type of the `artist_id` column on `songs` to be :integer. (For example `t.integer artist_id`). Original message: Mysql2::Error: Cannot add foreign key constraint: ALTER TABLE `songs` ADD CONSTRAINT `fk_rails_5ce8fd4cc7` FOREIGN KEY (`artist_id`) REFERENCES `artists` (`id`)
The problem, beyond generating an ineligible name for an index:
fk_rails_5ce8fd4cc7, is that
artist_id on my table was as
INT. The first thing I checked was to see if the
UNSIGNED and if my foreign key was also unsigned. They weren’t, but since were both signed, it wouldn’t throw an error. Looking more closely to the error message I noticed that the type in my foreign key column did not match the type on the primary key on the other table. Little did I know that Active Record generates the
id field not as an
INT, but as
I decided to go back and look at PostgreSQL, and to my surprise, and up to now I still am not sure of why, PostgreSQL did allow the column type mismatch where MySQL threw an error.
To fix it, I had to change the migration as follows:
Digging online, I found out how to create a
bigint field with AR. According to the post, this would only work on MySQL, which they did, but I found it also worked with PostgreSQL (I tested MySQL 5.7 and Postgres 9.6):
t.integer :artist_id, limit: 8.
limit is used to set a maximum length for string types or number of bytes for numbers.
Why type matching is important
INT let’s say you can fit your number inside an espresso cup. Sure you can use the Starbucks Venti size cup to fit your coffee, but the full content of a Venti would never fit an espresso cup.
In the specific domain I am working on if I had a big list of Artists, and happen to have an artist which ID was higher than 2,147,483,647 (signed, and for both PostgreSQL and MySQL), I would get an error when trying to insert it into the Songs table since an Artist
id can be up to 8 bytes (9,223,372,036,854,775,807).
Queen has its Artist
id as: 21474836481 (which is a
Trying to insert “We Will Rock you” in the
artist_id column for
********** Error ********** ERROR: integer out of range SQL state: 22003
This is the kind of problem we don’t usually notice in the beginning, and more often than not while the application is in production for even years, but this can happen and will happen if we don’t pay attention to foreign key types.
After that change, all the migrations ran smoothly. And I could actually move forward to the next problem (and post): Filtering a song title or artist name.