ActiveRecord, Intentionally truncate string to db column width - mysql

Question

In Rails 4, ActiveRecord and it's MySQL adapter are set up so if you try to save an attribute in an AR model to a MySQL db, where the attribute string length is too wide for the MySQL column limits -- you'll get an exception raised.
Great! This is much better default than Rails3, where it silently truncated the string.
However, occasionally I have an attribute that I explicitly want to be simply truncated to the maximum size allowed by the db, with no exception. I'm having trouble figuring out the best/supported way to do this with AR.
It should ideally happen as soon as the attribute is set, but I'd take it happening on save. (This isn't exactly a 'validation', as I never want to raise, just truncate, but maybe the validation system is the best supported way to do this?)
Ideally, it would automatically figure out the db column width through AR's db introspection, so if the db column width changed (in a later migration), the truncation limit would change accordingly. But if that's not possible, I'll take a hard-coded truncation limit.
Ideally it would be generic AR code that would work with any db, but if there's no good way to do that I'd take code that only worked for MySQL

Answer 1

You could truncate your data before inserting in db with a before_save or a before_validation
See Active Record Callbacks — Ruby on Rails Guides and ActiveRecord::Callbacks
You can retrieve informations on your table with MODEL.columns and MODEL.columns_hash.
See ActiveRecord::ModelSchema::ClassMethods
For example (not tested):
class User < ActiveRecord::Base
before_save :truncate_col
......
def truncate_col
col_size = User.columns_hash['your_column'].limit
self.your_column = self.your_column.truncate(col_size)
end
end

Answer 2

I'm pretty sure you can accomplish this with a combination of ActiveRecord callbacks and ConnectionsAdapters. ActiveRecord contains several callbacks you can override to perform specific logic at different points during the save flow. Since the exception is being thrown at save, I would recommend adding your logic to the before_save method. Using the column ConnectionAdapter you should be able to determine the limit of the column you wish to insert, though the logic will most likely be different for strings vs ints, etc. Off the top of my head you'll probably want to implement something like:
class User < ActiveRecord::Base
def before_save
limit = User.columns_hash['attribute'].limit
self.attribute = self.attribute[0..limit-1] if self.attribute.length > limit
end
end
The above example is for a string, but this solution should work for all connection adapters assuming they support the limit attribute. Hopefully that helps.

Answer 3

I'd like to address a few points:
If the data type of your_column is text, in Rails 4 User.columns_hash['your_column'].limit will return nil. It returns a number in case of int or varchar.
The text data type in MySQL has a storage limit of 64k. Meaning truncating upon char length is not enough if the content has non ascii chars like ç which needs more than 1 byte to be stored.
I've bumped into this problem very recently, here is a hotfix for it:
before_save :truncate_your_column_to_fit_into_max_storage_size
def truncate_your_column_to_fit_into_max_storage_size
return if your_column.blank?
max_field_size_in_bytes = 65_535
self.your_column = your_column[0, max_field_size_in_bytes]
while your_column.bytesize > max_field_size_in_bytes
self.your_column = your_column[0..-2]
end
end

Answer 4

Here's my own self-answer, which truncates on attribute set (way before save). Curious if anyone has any feedback. It seems to work!
# An ActiveRecord extension that will let you automatically truncate
# certain attributes to the maximum length allowed by the DB.
#
# require 'truncate_to_db_limit'
# class Something < ActiveRecord::Base
# extend TruncateToDbLimit
# truncate_to_db_limit :short_attr, :short_attr2
# #...
#
# Truncation is done whenever the attribute is set, NOT waiting
# until db save.
#
# For a varchar(4), if you do:
# model.short_attr = "123456789"
# model.short_attr # => '1234'
#
#
# We define an override to the `attribute_name=` method, which ActiveRecord, I think,
# promises to call just about all the time when setting the attribute. We call super
# after truncating the value.
module TruncateToDbLimit
def truncate_to_db_limit(*attribute_names)
attribute_names.each do |attribute_name|
ar_attr = columns_hash[attribute_name.to_s]
unless ar_attr
raise ArgumentError.new("truncate_to_db_limit #{attribute_name}: No such attribute")
end
limit = ar_attr.limit
unless limit && limit.to_i != 0
raise ArgumentError.new("truncate_to_db_limit #{attribute_name}: Limit not known")
end
define_method "#{attribute_name}=" do |val|
normalized = val.slice(0, limit)
super(normalized)
end
end
end
end