down is used when you run rails db:rollback, is that what you were trying to do?

up is used when running rails db:migrate. Usually Rails knows what to do so using change is enough in migrations, but sometimes you need do use up/down so the migration is reversible.

From the docs

You can also use the old style of migration using up and down methods instead of the change method. The up method should describe the transformation you'd like to make to your schema, and the down method of your migration should revert the transformations done by the up method. In other words, the database schema should be unchanged if you do an up followed by a down. For example, if you create a table in the up method, you should drop it in the down method.

Use the reload method for this.

model.reload(:select => "a")

OR

You can try the will_change! method(Its not clear how your change happens. But you can try this method).

model.update_attribute(:a, 1) # start it off at 1
model.a_will_change! #fore warn the model about the change
model.a = 2  #perform the change
model.update_attribute(:a, 1)

possible ActiveRecord 3.1.1 bug

The OP mentioned to me that he uses require "active_record" in a stand alone script (not using rails runner). There is no separate Rails application for his task, he just uses a script. This is not necessarily bad, and has worked in earlier ActiveRecord versions, e.g. 2.x AFAIK -- maybe this is a regression in Rails 3.1 due to a new dependency?

# the OP's require statements:
require 'rubygems'
require 'logger'
require 'yaml'
require 'uuidtools'
require 'active_record'

complete code here: https://raw.github.com/Zhengquan/Swap_Chars/master/lib/orm.rb

maybe a dependency is missing, or problem with AR 3.1.1 when initialized stand alone?

It could be a bug actually

It could be that update_attribute() triggers a bug in the dirty-tracking of attributes, which then incorrectly assumes that the object has not changed, and as a result it will not be persisted, although the implementation of update_attribute() calls save() (see code fragment below).

I've seen something like this with an older version of Mongoid -- could be that there is a similar hidden bug in your ActiveRecord version for update_attribute()

In the Rails Console monkey-patch update_attribute like this:

class ActiveRecord::Base
  def update_attribute(name, value) # make sure you use the exact code of your Rails Version here
    send(name.to_s + '=', value)
    puts "Changed?: #{changed?}"        # this produced false in the OP's scenario
    puts "valid?: #{valid?}"
    puts "errors: #{errors.inspect}"
    save
  end
end

then try to run your Code 1 again...

you shouldn't see "Changed?: false".. if it returns false, although you changed the attribute, then there is a bug in your ActiveRecord version and you should report it.

Code 1:

NOTE: check the definition of update_attribute() (singular) here: (please read the fine-print regarding validations -- it doesn't sound like a good idea to use that method)

http://ar.rubyonrails.org/classes/ActiveRecord/Base.html#M000400

See also:

Rails: update_attribute vs update_attributes

The source code for update_attribute() looks like this:

2260:       def update_attribute(name, value)
2261:         send(name.to_s + '=', value)
2262:         save
2263:       end

it could fail if there is a bug with the dirty-tracking of attributes...

Code 2:

The second code looks correct.

There are a couple of things to also consider:

1) which attributes did you define as accessible, via attr_accessible ?

e.g. only accessible attributes will be updated via update_attributes()

http://apidock.com/rails/ActiveRecord/Base/update_attributes

2) which validations do you use?

are you sure the validations pass for the record when you call update_attribute?

See also:

http://guides.rubyonrails.org/active_record_querying.html

http://m.onkey.org/active-record-query-interface

http://api.rubyonrails.org/classes/ActiveRecord/Base.html

For many operations rails can guess what is the inverse operation (without problems). For example, in your case what is the reverse operation of add_column to call when you rollback? Of course it's remove_column. What is the inverse of create_table? It's drop_table. So in these cases rails know how to rollback and define a down method is superfluous (you can see in the documentation the methods currently supported from the change method).

But pay attention because for some kind of operation you still need to define the down method, for example if you change the precision of a decimal column how to guess the original precision on rollback? It's not possible, so you need to define the down method.

As said, I suggest you to read the Rails Migrations Guide.