migration_comments 0.1.3 → 0.2.0

data/lib/migration_comments/active_record/connection_adapters/mysql2_adapter.rb

@@ -1,9 +1,9 @@
-module MigrationComments::ActiveRecord::ConnectionAdapters
-  module Mysql2Adapter
-    def self.included(base)
-      base.class_eval do
-        include MigrationComments::ActiveRecord::ConnectionAdapters::MysqlAdapter
-      end
-    end
-  end
+module MigrationComments::ActiveRecord::ConnectionAdapters
+  module Mysql2Adapter
+    def self.included(base)
+      base.class_eval do
+        include MigrationComments::ActiveRecord::ConnectionAdapters::MysqlAdapter
+      end
+    end
+  end
 end

data/lib/migration_comments/active_record/connection_adapters/mysql_adapter.rb

@@ -1,98 +1,104 @@
-module MigrationComments::ActiveRecord::ConnectionAdapters
-  module MysqlAdapter
-    def self.included(base)
-      base.class_eval do
-        attr_accessor :database_name
-        alias_method_chain :create_table, :migration_comments
-        alias_method_chain :change_column, :migration_comments
-      end
-    end
-
-    def set_table_comment(table_name, comment_text)
-      execute "ALTER TABLE #{table_name} COMMENT #{escaped_comment(comment_text)}"
-    end
-
-    def set_column_comment(table_name, column_name, comment_text)
-      column = column_for(table_name, column_name)
-      change_column table_name, column_name, column.sql_type, :comment => comment_text
-    end
-
-    def retrieve_table_comment(table_name)
-      result = select_rows(table_comment_sql(table_name))
-      result[0].nil? || result[0][0].blank? ? nil : result[0][0]
-    end
-
-    def retrieve_column_comments(table_name, *column_names)
-      result = select_rows(column_comment_sql(table_name, *column_names))
-      return {} if result.nil?
-      found = result.inject({}){|m, row| m[row[0].to_sym] = (row[1].blank? ? nil : row[1]); m}
-
-    end
-
-    def create_table_with_migration_comments(table_name, options={}, &block)
-      local_table_definition = nil
-      create_table_without_migration_comments(table_name, options) do |td|
-        local_table_definition = td
-        local_table_definition.comment options[:comment] if options.has_key?(:comment)
-        block.call(td)
-      end
-      comments = local_table_definition.collect_comments(table_name)
-      comments.each do |comment_definition|
-        execute_comment comment_definition
-      end
-    end
-
-    def change_column_with_migration_comments(table_name, column_name, type, options={})
-      unless options.keys.include?(:comment)
-        options.merge!(:comment => retrieve_column_comment(table_name, column_name))
-      end
-      change_column_without_migration_comments(table_name, column_name, type, options)
-    end
-
-    def add_column_options!(sql, options)
-      super(sql, options)
-      if options.keys.include?(:comment)
-        sql << " COMMENT #{escaped_comment(options[:comment])}"
-      end
-    end
-
-    def execute_comment(comment_definition)
-      if comment_definition.table_comment?
-        set_table_comment comment_definition.table_name, comment_definition.comment_text
-      else
-        set_column_comment comment_definition.table_name, comment_definition.column_name, comment_definition.comment_text
-      end
-    end
-
-    private
-    def escaped_comment(comment)
-      comment.nil? ? "''" : "'#{comment.gsub("'", "''").gsub("\\", "\\\\\\\\")}'"
-    end
-
-    def table_comment_sql(table_name)
-      ensure_database_name
-      <<SQL
-SELECT table_comment FROM INFORMATION_SCHEMA.TABLES
-  WHERE table_schema = '#{database_name}'
-  AND table_name = '#{table_name}'
-SQL
-    end
-
-    def column_comment_sql(table_name, *column_names)
-      ensure_database_name
-      col_matcher_sql = column_names.empty? ? "" : " AND column_name IN (#{column_names.map{|c_name| "'#{c_name}'"}.join(',')})"
-      <<SQL
-SELECT column_name, column_comment FROM INFORMATION_SCHEMA.COLUMNS
-  WHERE table_schema = '#{database_name}'
-  AND table_name = '#{table_name}' #{col_matcher_sql}
-SQL
-    end
-
-    def ensure_database_name
-      return if database_name
-      info = YAML::load(IO.read('config/database.yml'))
-      @database_name = info[ENV['DB'] || Rails.env.to_s]["database"]
-    end
-
-  end
+module MigrationComments::ActiveRecord::ConnectionAdapters
+  module MysqlAdapter
+    def self.included(base)
+      base.class_eval do
+        attr_accessor :database_name
+        alias_method_chain :create_table, :migration_comments
+        alias_method_chain :change_column, :migration_comments
+      end
+    end
+
+    def set_table_comment(table_name, comment_text)
+      execute "ALTER TABLE #{quote_table_name table_name} COMMENT #{escaped_comment(comment_text)}"
+    end
+
+    def set_column_comment(table_name, column_name, comment_text)
+      pk_info = pk_and_sequence_for(table_name)
+      if pk_info && pk_info.first == column_name.to_s             # change_column broken for :primary_key
+        primary_col_def = native_database_types[:primary_key].sub(/ PRIMARY KEY/i, '')
+        execute "ALTER TABLE #{quote_table_name table_name} CHANGE #{quote_column_name column_name} #{quote_column_name column_name} #{primary_col_def} COMMENT #{escaped_comment(comment_text)};"
+      else
+        column = column_for(table_name, column_name)
+        change_column table_name, column_name, column.sql_type, :comment => comment_text
+      end
+    end
+
+    def retrieve_table_comment(table_name)
+      result = select_rows(table_comment_sql(table_name))
+      result[0].nil? || result[0][0].blank? ? nil : result[0][0]
+    end
+
+    def retrieve_column_comments(table_name, *column_names)
+      result = select_rows(column_comment_sql(table_name, *column_names))
+      return {} if result.nil?
+      found = result.inject({}){|m, row| m[row[0].to_sym] = (row[1].blank? ? nil : row[1]); m}
+
+    end
+
+    def create_table_with_migration_comments(table_name, options={}, &block)
+      local_table_definition = nil
+      create_table_without_migration_comments(table_name, options) do |td|
+        local_table_definition = td
+        local_table_definition.comment options[:comment] if options.has_key?(:comment)
+        block.call(td)
+      end
+      comments = local_table_definition.collect_comments(table_name)
+      comments.each do |comment_definition|
+        execute_comment comment_definition
+      end
+    end
+
+    def change_column_with_migration_comments(table_name, column_name, type, options={})
+      unless options.keys.include?(:comment)
+        options.merge!(:comment => retrieve_column_comment(table_name, column_name))
+      end
+      change_column_without_migration_comments(table_name, column_name, type, options)
+    end
+
+    def add_column_options!(sql, options)
+      super(sql, options)
+      if options.keys.include?(:comment)
+        sql << " COMMENT #{escaped_comment(options[:comment])}"
+      end
+    end
+
+    def execute_comment(comment_definition)
+      if comment_definition.table_comment?
+        set_table_comment comment_definition.table_name, comment_definition.comment_text
+      else
+        set_column_comment comment_definition.table_name, comment_definition.column_name, comment_definition.comment_text
+      end
+    end
+
+    private
+    def escaped_comment(comment)
+      comment.nil? ? "''" : "'#{comment.gsub("'", "''").gsub("\\", "\\\\\\\\")}'"
+    end
+
+    def table_comment_sql(table_name)
+      ensure_database_name
+      <<SQL
+SELECT table_comment FROM INFORMATION_SCHEMA.TABLES
+  WHERE table_schema = '#{database_name}'
+  AND table_name = '#{table_name}'
+SQL
+    end
+
+    def column_comment_sql(table_name, *column_names)
+      ensure_database_name
+      col_matcher_sql = column_names.empty? ? "" : " AND column_name IN (#{column_names.map{|c_name| "'#{c_name}'"}.join(',')})"
+      <<SQL
+SELECT column_name, column_comment FROM INFORMATION_SCHEMA.COLUMNS
+  WHERE table_schema = '#{database_name}'
+  AND table_name = '#{table_name}' #{col_matcher_sql}
+SQL
+    end
+
+    def ensure_database_name
+      return if database_name
+      info = YAML::load(IO.read('config/database.yml'))
+      @database_name = info[ENV['DB'] || Rails.env.to_s]["database"]
+    end
+
+  end
 end

data/lib/migration_comments/active_record/connection_adapters/postgresql_adapter.rb

@@ -1,111 +1,111 @@
-module MigrationComments::ActiveRecord::ConnectionAdapters
-  module PostgreSQLAdapter
-    def self.included(base)
-      base.class_eval do
-        alias_method_chain :create_table, :migration_comments
-        alias_method_chain :add_column, :migration_comments
-        alias_method_chain :change_column, :migration_comments
-      end
-    end
-
-    def comments_supported?
-      true
-    end
-
-    # Set a comment on a table
-    def set_table_comment(table_name, comment_text)
-      execute CommentDefinition.new(self, table_name, nil, comment_text).to_sql
-    end
-
-    # Set a comment on a column
-    def set_column_comment(table_name, column_name, comment_text)
-      execute CommentDefinition.new(self, table_name, column_name, comment_text).to_sql
-    end
-
-    def retrieve_table_comment(table_name)
-      result = select_rows(table_comment_sql(table_name))
-      result[0].nil? ? nil : result[0][0]
-    end
-
-    def retrieve_column_comments(table_name, *column_names)
-      result = select_rows(column_comment_sql(table_name, *column_names))
-      return {} if result.nil?
-      return result.inject({}){|m, row| m[row[0].to_sym] = row[1]; m}
-    end
-
-    def create_table_with_migration_comments(table_name, options = {}, &block)
-      local_table_definition = nil
-      create_table_without_migration_comments(table_name, options) do |td|
-        local_table_definition = td
-        local_table_definition.comment options[:comment] if options.has_key?(:comment)
-        block.call(td)
-      end
-      comments = local_table_definition.collect_comments(table_name)
-      comments.each do |comment_definition|
-        execute comment_definition.to_sql
-      end
-    end
-
-    def add_column_with_migration_comments(table_name, column_name, type, options = {})
-      add_column_without_migration_comments(table_name, column_name, type, options)
-      if options[:comment]
-        set_column_comment(table_name, column_name, options[:comment])
-      end
-    end
-
-    def change_column_with_migration_comments(table_name, column_name, type, options = {})
-      change_column_without_migration_comments(table_name, column_name, type, options)
-      if options.keys.include?(:comment)
-        set_column_comment(table_name, column_name, options[:comment])
-      end
-    end
-
-    def comment_sql(comment_definition)
-      "COMMENT ON #{comment_target(comment_definition)} IS #{escaped_comment(comment_definition.comment_text)}"
-    end
-
-    private
-
-    private
-    def comment_target(comment_definition)
-      comment_definition.table_comment? ?
-          "TABLE #{quote_table_name(comment_definition.table_name)}" :
-          "COLUMN #{quote_table_name(comment_definition.table_name)}.#{quote_column_name(comment_definition.column_name)}"
-    end
-
-    def escaped_comment(comment)
-      comment.nil? ? 'NULL' : "'#{comment.gsub("'", "''")}'"
-    end
-
-    def table_comment_sql(table_name)
-      <<SQL
-SELECT d.description FROM (
-#{table_oids(table_name)}) tt
-JOIN pg_catalog.pg_description d
-  ON tt.oid = d.objoid AND tt.tableoid = d.classoid AND d.objsubid = 0;
-SQL
-    end
-
-    def column_comment_sql(table_name, *column_names)
-      col_matcher_sql = column_names.empty? ? "" : " a.attname IN (#{column_names.map{|c_name| "'#{c_name}'"}.join(',')}) AND "
-      <<SQL
-SELECT a.attname, pg_catalog.col_description(a.attrelid, a.attnum)
-FROM pg_catalog.pg_attribute a
-JOIN (
-#{table_oids(table_name)}) tt
-  ON tt.oid = a.attrelid
-WHERE #{col_matcher_sql} a.attnum > 0 AND NOT a.attisdropped;
-SQL
-    end
-
-    def table_oids(table_name)
-      <<SQL
-SELECT c.oid, c.tableoid
-FROM pg_catalog.pg_class c
-WHERE c.relname = '#{table_name}'
-  AND c.relkind = 'r'
-  AND pg_catalog.pg_table_is_visible(c.oid)
-SQL
-    end
-  end
-end
+module MigrationComments::ActiveRecord::ConnectionAdapters
+  module PostgreSQLAdapter
+    def self.included(base)
+      base.class_eval do
+        alias_method_chain :create_table, :migration_comments
+        alias_method_chain :add_column, :migration_comments
+        alias_method_chain :change_column, :migration_comments
+      end
+    end
+
+    def comments_supported?
+      true
+    end
+
+    # Set a comment on a table
+    def set_table_comment(table_name, comment_text)
+      execute CommentDefinition.new(self, table_name, nil, comment_text).to_sql
+    end
+
+    # Set a comment on a column
+    def set_column_comment(table_name, column_name, comment_text)
+      execute CommentDefinition.new(self, table_name, column_name, comment_text).to_sql
+    end
+
+    def retrieve_table_comment(table_name)
+      result = select_rows(table_comment_sql(table_name))
+      result[0].nil? ? nil : result[0][0]
+    end
+
+    def retrieve_column_comments(table_name, *column_names)
+      result = select_rows(column_comment_sql(table_name, *column_names))
+      return {} if result.nil?
+      return result.inject({}){|m, row| m[row[0].to_sym] = row[1]; m}
+    end
+
+    def create_table_with_migration_comments(table_name, options = {}, &block)
+      local_table_definition = nil
+      create_table_without_migration_comments(table_name, options) do |td|
+        local_table_definition = td
+        local_table_definition.comment options[:comment] if options.has_key?(:comment)
+        block.call(td)
+      end
+      comments = local_table_definition.collect_comments(table_name)
+      comments.each do |comment_definition|
+        execute comment_definition.to_sql
+      end
+    end
+
+    def add_column_with_migration_comments(table_name, column_name, type, options = {})
+      add_column_without_migration_comments(table_name, column_name, type, options)
+      if options[:comment]
+        set_column_comment(table_name, column_name, options[:comment])
+      end
+    end
+
+    def change_column_with_migration_comments(table_name, column_name, type, options = {})
+      change_column_without_migration_comments(table_name, column_name, type, options)
+      if options.keys.include?(:comment)
+        set_column_comment(table_name, column_name, options[:comment])
+      end
+    end
+
+    def comment_sql(comment_definition)
+      "COMMENT ON #{comment_target(comment_definition)} IS #{escaped_comment(comment_definition.comment_text)}"
+    end
+
+    private
+
+    private
+    def comment_target(comment_definition)
+      comment_definition.table_comment? ?
+          "TABLE #{quote_table_name(comment_definition.table_name)}" :
+          "COLUMN #{quote_table_name(comment_definition.table_name)}.#{quote_column_name(comment_definition.column_name)}"
+    end
+
+    def escaped_comment(comment)
+      comment.nil? ? 'NULL' : "'#{comment.gsub("'", "''")}'"
+    end
+
+    def table_comment_sql(table_name)
+      <<SQL
+SELECT d.description FROM (
+#{table_oids(table_name)}) tt
+JOIN pg_catalog.pg_description d
+  ON tt.oid = d.objoid AND tt.tableoid = d.classoid AND d.objsubid = 0;
+SQL
+    end
+
+    def column_comment_sql(table_name, *column_names)
+      col_matcher_sql = column_names.empty? ? "" : " a.attname IN (#{column_names.map{|c_name| "'#{c_name}'"}.join(',')}) AND "
+      <<SQL
+SELECT a.attname, pg_catalog.col_description(a.attrelid, a.attnum)
+FROM pg_catalog.pg_attribute a
+JOIN (
+#{table_oids(table_name)}) tt
+  ON tt.oid = a.attrelid
+WHERE #{col_matcher_sql} a.attnum > 0 AND NOT a.attisdropped;
+SQL
+    end
+
+    def table_oids(table_name)
+      <<SQL
+SELECT c.oid, c.tableoid
+FROM pg_catalog.pg_class c
+WHERE c.relname = '#{table_name}'
+  AND c.relkind = 'r'
+  AND pg_catalog.pg_table_is_visible(c.oid)
+SQL
+    end
+  end
+end

data/lib/migration_comments/active_record/connection_adapters/sqlite_adapter.rb

@@ -1,140 +1,142 @@
-module MigrationComments::ActiveRecord::ConnectionAdapters
-  module SQLiteAdapter
-    def self.included(base)
-      base.class_eval do
-        alias_method_chain :columns, :migration_comments
-        alias_method_chain :copy_table, :migration_comments
-        alias_method_chain :change_column, :migration_comments
-      end
-    end
-
-    def set_table_comment(table_name, comment_text)
-      alter_table(table_name, :comment => comment_text)
-    end
-
-    def set_column_comment(table_name, column_name, comment_text)
-      column = column_for(table_name, column_name)
-      change_column table_name, column_name, column.sql_type, :comment => comment_text
-    end
-
-    def retrieve_table_comment(table_name)
-      result = select_rows(lookup_comment_sql(table_name))
-      if result[0][0] =~ /CREATE (?:TEMPORARY )?TABLE #{quote_table_name table_name} [^\(]*\/\*(.*)\*\/ \(/
-        $1
-      end
-    end
-
-    def retrieve_column_comments(table_name, *column_names)
-      if column_names.empty?
-        return columns(table_name).inject({}) { |m, v| m[v.name.to_sym] = v.comment if v.comment.present?; m }
-      end
-      result = select_rows(lookup_comment_sql(table_name))
-      result[0][0] =~ /^CREATE (?:TEMPORARY )?TABLE "\w*" [^\(]*(?:\/\*.*\*\/ )?\((.*)\)[^\)]*$/
-      col_defs = $1
-      comment_matches = col_defs.scan(/"([^",]+)"[^,]*\/\*(.+?)\*\//)
-      comment_matches.inject({}){|m, row| m[row.first.to_sym] = row.last; m}
-    end
-
-    def create_table(table_name, options = {})
-      td = table_definition
-      td.primary_key(options[:primary_key] || ActiveRecord::Base.get_primary_key(table_name.to_s.singularize)) unless options[:id] == false
-      td.comment options[:comment] if options.has_key?(:comment)
-
-      yield td if block_given?
-
-      if options[:force] && table_exists?(table_name)
-        drop_table(table_name)
-      end
-
-      create_sql = "CREATE#{' TEMPORARY' if options[:temporary]} TABLE "
-      create_sql << "#{quote_table_name(table_name)}#{td.table_comment} ("
-      create_sql << td.columns.map do |column|
-        column.to_sql + column.comment.to_sql
-      end * ", "
-      create_sql << ") #{options[:options]}"
-      execute create_sql
-    end
-
-    def change_column_with_migration_comments(table_name, column_name, type, options = {}) #:nodoc:
-      adapter = self
-      alter_table(table_name) do |definition|
-        include_default = options_include_default?(options)
-        definition[column_name].instance_eval do
-          self.type    = type
-          self.limit   = options[:limit] if options.include?(:limit)
-          self.default = options[:default] if include_default
-          self.null    = options[:null] if options.include?(:null)
-          self.precision = options[:precision] if options.include?(:precision)
-          self.scale   = options[:scale] if options.include?(:scale)
-          self.comment = CommentDefinition.new(adapter, table_name, column_name, options[:comment]) if options.include?(:comment)
-        end
-      end
-    end
-
-    def columns_with_migration_comments(table_name, name = nil)
-      cols = columns_without_migration_comments(table_name, name)
-      comments = retrieve_column_comments(table_name, *(cols.map(&:name)))
-      cols.each do |col|
-        col.comment = comments[col.name.to_sym] if comments.has_key?(col.name.to_sym)
-      end
-      cols
-    end
-
-    def column_for(table_name, column_name)
-      columns(table_name).detect{|col| col.name == column_name.to_s}
-    end
-
-    def comment_sql(comment_definition)
-      if comment_definition.nil? || comment_definition.comment_text.blank?
-        ""
-      else
-        " /*#{escaped_comment(comment_definition.comment_text)}*/"
-      end
-
-    end
-
-    def copy_table_with_migration_comments(from, to, options = {}) #:nodoc:
-      options = options.merge(:id => (!columns(from).detect{|c| c.name == 'id'}.nil? && 'id' == primary_key(from).to_s))
-      unless options.has_key?(:comment)
-        table_comment = retrieve_table_comment(from)
-        options = options.merge(:comment => table_comment) if table_comment
-      end
-      create_table(to, options) do |definition|
-        @definition = 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,
-            :precision => column.precision, :scale => column.scale,
-            :null => column.null, :comment => column.comment)
-        end
-        @definition.primary_key(primary_key(from)) if primary_key(from)
-        yield @definition if block_given?
-      end
-
-      copy_table_indexes(from, to, options[:rename] || {})
-      copy_table_contents(from, to,
-        @definition.columns.map {|column| column.name},
-        options[:rename] || {})
-    end
-
-    def add_column_options!(sql, options)
-      super(sql, options)
-      if options.keys.include?(:comment)
-        sql << CommentDefinition.new(self, nil, nil, options[:comment]).to_sql
-      end
-    end
-
-    private
-    def escaped_comment(comment)
-      comment.gsub(/\*\//, "*-/")
-    end
-
-    def lookup_comment_sql(table_name)
-      "select sql from (select * from sqlite_master where type='table' union select * from sqlite_temp_master where type='table') where tbl_name = '#{table_name}'"
-    end
-  end
+module MigrationComments::ActiveRecord::ConnectionAdapters
+  module SQLiteAdapter
+    def self.included(base)
+      base.class_eval do
+        alias_method_chain :columns, :migration_comments
+        alias_method_chain :copy_table, :migration_comments
+        alias_method_chain :change_column, :migration_comments
+      end
+    end
+
+    def set_table_comment(table_name, comment_text)
+      alter_table(table_name, :comment => comment_text)
+    end
+
+    def set_column_comment(table_name, column_name, comment_text)
+      sql_type = primary_key(table_name) == column_name.to_s ?
+          :primary_key :
+          column_for(table_name, column_name).sql_type
+      change_column table_name, column_name, sql_type, :comment => comment_text
+    end
+
+    def retrieve_table_comment(table_name)
+      result = select_rows(lookup_comment_sql(table_name))
+      if result[0][0] =~ /CREATE (?:TEMPORARY )?TABLE #{quote_table_name table_name} [^\(]*\/\*(.*)\*\/ \(/
+        $1
+      end
+    end
+
+    def retrieve_column_comments(table_name, *column_names)
+      if column_names.empty?
+        return columns(table_name).inject({}) { |m, v| m[v.name.to_sym] = v.comment if v.comment.present?; m }
+      end
+      result = select_rows(lookup_comment_sql(table_name))
+      result[0][0] =~ /^CREATE (?:TEMPORARY )?TABLE "\w*" [^\(]*(?:\/\*.*\*\/ )?\((.*)\)[^\)]*$/
+      col_defs = $1
+      comment_matches = col_defs.scan(/"([^",]+)"[^,]*\/\*(.+?)\*\//)
+      comment_matches.inject({}){|m, row| m[row.first.to_sym] = row.last; m}
+    end
+
+    def create_table(table_name, options = {})
+      td = table_definition
+      td.primary_key(options[:primary_key] || ActiveRecord::Base.get_primary_key(table_name.to_s.singularize)) unless options[:id] == false
+      td.comment options[:comment] if options.has_key?(:comment)
+
+      yield td if block_given?
+
+      if options[:force] && table_exists?(table_name)
+        drop_table(table_name)
+      end
+
+      create_sql = "CREATE#{' TEMPORARY' if options[:temporary]} TABLE "
+      create_sql << "#{quote_table_name(table_name)}#{td.table_comment} ("
+      create_sql << td.columns.map do |column|
+        column.to_sql + column.comment.to_s
+      end * ", "
+      create_sql << ") #{options[:options]}"
+      execute create_sql
+    end
+
+    def change_column_with_migration_comments(table_name, column_name, type, options = {}) #:nodoc:
+      adapter = self
+      alter_table(table_name) do |definition|
+        include_default = options_include_default?(options)
+        definition[column_name].instance_eval do
+          self.type    = type
+          self.limit   = options[:limit] if options.include?(:limit)
+          self.default = options[:default] if include_default
+          self.null    = options[:null] if options.include?(:null)
+          self.precision = options[:precision] if options.include?(:precision)
+          self.scale   = options[:scale] if options.include?(:scale)
+          self.comment = CommentDefinition.new(adapter, table_name, column_name, options[:comment]) if options.include?(:comment)
+        end
+      end
+    end
+
+    def columns_with_migration_comments(table_name, name = nil)
+      cols = columns_without_migration_comments(table_name, name)
+      comments = retrieve_column_comments(table_name, *(cols.map(&:name)))
+      cols.each do |col|
+        col.comment = comments[col.name.to_sym] if comments.has_key?(col.name.to_sym)
+      end
+      cols
+    end
+
+    def column_for(table_name, column_name)
+      columns(table_name).detect{|col| col.name == column_name.to_s}
+    end
+
+    def comment_sql(comment_definition)
+      if comment_definition.nil? || comment_definition.comment_text.blank?
+        ""
+      else
+        " /*#{escaped_comment(comment_definition.comment_text)}*/"
+      end
+
+    end
+
+    def copy_table_with_migration_comments(from, to, options = {}) #:nodoc:
+      options = options.merge(:id => (!columns(from).detect{|c| c.name == 'id'}.nil? && 'id' == primary_key(from).to_s))
+      unless options.has_key?(:comment)
+        table_comment = retrieve_table_comment(from)
+        options = options.merge(:comment => table_comment) if table_comment
+      end
+      create_table(to, options) do |definition|
+        @definition = 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,
+            :precision => column.precision, :scale => column.scale,
+            :null => column.null, :comment => column.comment)
+        end
+        @definition.primary_key(primary_key(from)) if primary_key(from)
+        yield @definition if block_given?
+      end
+
+      copy_table_indexes(from, to, options[:rename] || {})
+      copy_table_contents(from, to,
+        @definition.columns.map {|column| column.name},
+        options[:rename] || {})
+    end
+
+    def add_column_options!(sql, options)
+      super(sql, options)
+      if options.keys.include?(:comment)
+        sql << CommentDefinition.new(self, nil, nil, options[:comment]).to_sql
+      end
+    end
+
+    private
+    def escaped_comment(comment)
+      comment.gsub(/\*\//, "*-/")
+    end
+
+    def lookup_comment_sql(table_name)
+      "select sql from (select * from sqlite_master where type='table' union select * from sqlite_temp_master where type='table') where tbl_name = '#{table_name}'"
+    end
+  end
 end