AkitaOnRails

</div>

O problema, exclusivo do SQLite, acontece toda vez que uma migration roda para adicionar uma nova coluna (add_column). No SQLite. o 'ALTER TABLE' não é muito completo, então o migration faz o seguinte: cria uma tabela temporária com o mesmo schema, transfere os dados da tabela antiga, dá um drop na tabela antiga, cria a nova tabela com a coluna extra, retransfere os dados da tabela temporária e finalmente dá drop dessa tabela. 

Em outros bancos isso não acontece porque é só usar o bom e velho 'ALTER TABLE XXX ADD COLUMN XXX'. Mas no caso do SQLite, ele precisa fazer um dump do schema para gerar a tabela temporária, e nesse processo, ele ignora que minha primary key é na realidade um String e cria outra como Integer, e a partir daí tudo começa a quebrar.

Para corrigir isso, felizmente podemos fazer o que todo plugin para ActiveRecord faz: Mixins. Então, este foi o código que incorporei no ActsAsReplica para eliminar esse problema (o código é longo, é bom dar copy & paste em algum editor de texto para visualizar melhor):

<div style="overflow: auto; width: 450px; height: 450px">
--- ruby" style="overflow: auto;
module ActiveRecord
  # Fix for SQLite where the primary key type is incorrectly inferred to be
  # always :integer. 
  class SchemaDumper #:nodoc:
    private
    def table(table, stream)
      columns = @connection.columns(table)
      begin
        tbl = StringIO.new

        if @connection.respond_to?(:pk_and_sequence_for)
          pk, pk_seq = @connection.pk_and_sequence_for(table)
        end
              
        # (1)
        if @connection.respond_to?(:primary_key)
          pk = @connection.primary_key(table)
        end
        pk ||= 'id'

        tbl.print "  create_table #{table.inspect}"
        # only consider the column 'id' as primary key if it is the default Rails' integer
        # (2)
        if columns.detect { |c| c.name == pk and c.type == :integer }
          if pk != 'id'
            tbl.print %Q(, :primary_key => "#{pk}")
          end
        else
          tbl.print ", :id => false"
        end
        tbl.print ", :force => true"
        tbl.puts " do |t|"

        column_specs = columns.map do |column|
          raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" if @types[column.type].nil?
          # only consider the column 'id' as primary key if it is the default Rails' integer
          # (3)
          next if column.name == pk and column.type == :integer
          spec = {}
          spec[:name]    = column.name.inspect
          # (4)
          spec[:type]    = column.name == pk ? "#{column.sql_type} PRIMARY KEY".inspect : column.type.inspect
          spec[:limit]   = column.limit.inspect if column.limit != @types[column.type][:limit] && column.type != :decimal && column.name != pk
          spec[:precision] = column.precision.inspect if !column.precision.nil?
          spec[:scale] = column.scale.inspect if !column.scale.nil?
          spec[:null]    = 'false' if !column.null
          spec[:default] = default_string(column.default) if !column.default.nil?
          (spec.keys - [:name, :type]).each{ |k| spec[k].insert(0, "#{k.inspect} => ")}
          spec
        end.compact
        keys = [:name, :type, :limit, :precision, :scale, :default, :null] & column_specs.map{ |spec| spec.keys }.inject([]){ |a,b| a | b }
        lengths = keys.map{ |key| column_specs.map{ |spec| spec[key] ? spec[key].length + 2 : 0 }.max }
        format_string = lengths.map{ |len| "%-#{len}s" }.join("")
        column_specs.each do |colspec|
          values = keys.zip(lengths).map{ |key, len| colspec.key?(key) ? colspec[key] + ", " : " " * len }
          tbl.print "    t.column "
          tbl.print((format_string % values).gsub(/,\s*$/, ''))
          tbl.puts
        end

        tbl.puts "  end"
        tbl.puts
      
        indexes(table, tbl)

        tbl.rewind
        stream.print tbl.read
      rescue => e
        stream.puts "# Could not dump table #{table.inspect} because of following #{e.class}"
        stream.puts "#   #{e.message}"
        stream.puts
      end
    
      stream
    end
  end

  module ConnectionAdapters #:nodoc:
    class TableDefinition
      # (5) the sqlite adapter forces the type of the primary key to integer
      # this fix makes it flexible
      @@default_primary_key_type = :primary_key
      cattr_accessor :default_primary_key_type

      def primary_key(name)
        column(name, default_primary_key_type)
      end
    end

    class SQLiteAdapter
      # (1) MIGRATION ISSUE
      class << self
        @@migration_vacuum = false
        cattr_accessor :migration_vacuum
      end
    
      # (2) MIGRATION ISSUE
      def add_column(table_name, column_name, type, options = {}) #:nodoc:
        super(table_name, column_name, type, options)        
        # This is too slow to run on every run, so defer running it very late in the
        # migration process
        # See last paragraph on https://www.sqlite.org/lang_altertable.html
        #execute "VACUUM"
        ActiveRecord::ConnectionAdapters::SQLiteAdapter.migration_vacuum = true
      end
    
      def copy_table(from, to, options = {}) #:nodoc:

        # (6) this fix ensure that the correct primary key type is maintained
        # between migration changes
        pk = primary_key(from)
        pk_col = columns(from).select {|c| c.name == pk }
        pk_col = pk_col.first if pk_col && pk_col.size > 0
    
        # (7)
        old_type = ActiveRecord::ConnectionAdapters::TableDefinition.default_primary_key_type
        ActiveRecord::ConnectionAdapters::TableDefinition.default_primary_key_type = "#{pk_col.sql_type} PRIMARY KEY NOT NULL"
        begin
          create_table(to, options) do |@definition|
            columns(from).each do |column|
              column_name = options[:rename] ?
                (options[:rename][column.name] ||
                 options[:rename][column.name.to_sym] ||
                 column.name) : column.name

              @definition.column(column_name, column.type,
                :limit => column.limit, :default => column.default,
                :null => column.null)
            end
            @definition.primary_key(primary_key(from))
            yield @definition if block_given?
          end
      
        ensure
          # (8)
          ActiveRecord::ConnectionAdapters::TableDefinition.default_primary_key_type = old_type
        end
      
        copy_table_indexes(from, to)
        copy_table_contents(from, to,
          @definition.columns.map {|column| column.name},
          options[:rename] || {})
      end
    end
  end

  class Migration
    class << self
      alias :old_migrate :migrate
      def migrate(direction)
        old_migrate(direction)
        # ensure that deferred vacuums run at the very end of each migration file
        # could have deferred it to the very end of migration series but this could
        # cause very nasty problem if the newly added columns are needed still inside
        # one of the migration files before vacuuming

        # (3) MIGRATION ISSUE
        begin
          execute('VACUUM') if direction == :up && Base.connection.adapter_name =~ /^SQLite/ && 
            ActiveRecord::ConnectionAdapters::SQLiteAdapter.migration_vacuum
        ensure
          ActiveRecord::ConnectionAdapters::SQLiteAdapter.migration_vacuum = false
        end
      end
    end
  end
end