How does rails knows that migration is pending?

Ronak Gupta — Sat, 11 May 2024 19:03:17 +0000

You might have enountered an condition of migration pending when you are trying to access a route, we may wonder sometime how does rails knows that migrations are pending.

Rails keeps the track of every migration that has been ran in a table schema_migration. This table has only one column version that store the version of migration files.

Versions are the creation timestamp of migration file, this version makes every migration unique from each other. So every time we runs a migration, corresponding version are stored in this table and whenever we runs a rollback corresponding version are removed from the table.

How schema_migration table is created

If we check the source of code of activerecord gem, we can see SchemaMigration class. This class is reponsible for table creation and all related operation like insertion and deletion in the table.

Some important method from SchemaMigration class

class SchemaMigration # :nodoc:
    class NullSchemaMigration # :nodoc:
    end

    attr_reader :arel_table

    def initialize(pool)
      @pool = pool
      @arel_table = Arel::Table.new(table_name)
    end

    def create_version(version)
      im = Arel::InsertManager.new(arel_table)
      im.insert(arel_table[primary_key] => version)
      @pool.with_connection do |connection|
        connection.insert(im, "#{self.class} Create", primary_key, version)
      end
    end

    def delete_version(version)
      dm = Arel::DeleteManager.new(arel_table)
      dm.wheres = [arel_table[primary_key].eq(version)]

      @pool.with_connection do |connection|
        connection.delete(dm, "#{self.class} Destroy")
      end
    def create_table
      @pool.with_connection do |connection|
        unless connection.table_exists?(table_name)
          connection.create_table(table_name, id: false) do |t|
            t.string :version, **connection.internal_string_options_for_primary_key
          end
        end
      end
    end
end

In above code, create_table create a table in database and create_version inserts version in table and delete_version removes version from table. Other method are also available in source code.

How does rails raise pending migration error

In Migration class in activerecord gem there is class available CheckPending

call method from CheckPending class

  def call(env)
        mtime = ActiveRecord::Base.connection.migration_context.last_migration.mtime.to_i
        if @last_check < mtime
          ActiveRecord::Migration.check_pending!(connection)
          @last_check = mtime
        end
        @app.call(env)
      end

This call method in CheckPending class calls an another method of Migration class check_pending!

Some methods from Migration class

def check_pending!(connection = Base.connection)
        raise ActiveRecord::PendingMigrationError if connection.migration_context.needs_migration?
      end

def needs_migration?
  (migrations.collect(&:version) - get_all_versions).size > 0
end

def get_all_versions
   if SchemaMigration.table_exists?
     SchemaMigration.all_versions.map(&:to_i)
   else
     []
   end
end

In above code, check_pending! calls the need_migration? method that calls the get_all_versions method. get_all_versions method with the help of SchemaMigration give all version to need_migration? method which check if number of migration files are equal to number of versions available in schema_migration table. If schema_migration table have less numbers of version it means there are some pending migration.

Migration class also have an another class PendingMigrationError which have details of error for pending migrations.

CheckPending and PendingMigrationError classes are accessed from railtie class during initialization.

Conclusion

In conclusion, ruby on rails are designed with detailing to ensure its smoothness and thats what makes it different from other frameworks.

I would love to know your reviews on this article. If you liked it or if you have any suggestion please put a comment.

Should we use DRY code pattern ?

Ronak Gupta — Wed, 04 Oct 2023 14:01:02 +0000

Is it always good to have DRY(don't repeat yourself) code pattern?

DRY is a software principal which aims to reduce the repition of code means don't repeat your code. Write your code in module, function, methods or classes so that you can use it anywhere anytime, without writing it again and again.

Here is the advantage:

-> You don't have to write code again and again.
-> It take less memory (which we don't bother most of the time).
-> You need to change only at one place, when there is any change in the algorithm.

But here what I experienced:

Let's assume there is large codebase of a social media, there is a function which is performing some task, let's assume creating a comment. Now, this function is used by many users (admin, creator, viewer) to create comment. Here it is best to use DRY code because all users are creating comment in same way, but we want to change some logic of any user there is some headache occurs. Let's assume for 'special user' we want to add functionality to add stickers. Now we have to change basic functionality of comment function.Whenever we are changing something we also need to make sure if everything is working fine for other users as well.

Have you also experienced this?
Would love to hear your opinions.

Why Java is not pure OOPS?

Ronak Gupta — Thu, 17 Aug 2023 17:30:16 +0000

I know one reason and that is,
Java allows data types like int, float , char which is neither a class nor a object. According to OOPS concept they should be either object or class. Hence, it is not pure Object Oriented Programming.