lib/migrate.rb

   1 module ActiveRecord
   2   module ConnectionAdapters
   3     module SchemaStatements
   4       def quote_column_names(column_name)
   5         Array(column_name).map { |e| quote_column_name(e) }.join(", ")
   6       end
   7
   8       def add_primary_key(table_name, column_name, options = {})
   9         column_names = Array(column_name)
  10         quoted_column_names = column_names.map { |e| quote_column_name(e) }.join(", ")
  11         execute "ALTER TABLE #{table_name} ADD PRIMARY KEY (#{quoted_column_names})"
  12       end
  13
  14       def remove_primary_key(table_name)
  15         execute "ALTER TABLE #{table_name} DROP PRIMARY KEY"
  16       end
  17
  18       def add_foreign_key(table_name, column_name, reftbl, refcol = nil)
  19         execute "ALTER TABLE #{table_name} ADD " +
  20           "FOREIGN KEY (#{quote_column_names(column_name)}) " +
  21           "REFERENCES #{reftbl} (#{quote_column_names(refcol || column_name)})"
  22       end
  23
  24       def remove_foreign_key(table_name, column_name, reftbl, refcol = nil)
  25         execute "ALTER TABLE #{table_name} DROP " +
  26           "CONSTRAINT #{table_name}_#{column_name[0]}_fkey"
  27       end
  28
  29       alias_method :old_options_include_default?, :options_include_default?
  30
  31       def options_include_default?(options)
  32         return false if options[:options] =~ /AUTO_INCREMENT/i
  33         return old_options_include_default?(options)
  34       end
  35
  36       alias_method :old_add_column_options!, :add_column_options!
  37
  38       def add_column_options!(sql, options)
  39         sql << " UNSIGNED" if options[:unsigned]
  40         old_add_column_options!(sql, options)
  41         sql << " #{options[:options]}"
  42       end
  43     end
  44
  45     if defined?(ActiveRecord::ConnectionAdapters::MysqlAdapter)
  46       class MysqlAdapter
  47         alias_method :old_native_database_types, :native_database_types
  48
  49         def native_database_types
  50           types = old_native_database_types
  51           types[:bigint] = { :name => "bigint", :limit => 20 }
  52           types[:double] = { :name => "double" }
  53           types[:integer_pk] = { :name => "integer DEFAULT NULL auto_increment PRIMARY KEY" }
  54           types[:bigint_pk] = { :name => "bigint(20) DEFAULT NULL auto_increment PRIMARY KEY" }
  55           types[:bigint_pk_64] = { :name => "bigint(64) DEFAULT NULL auto_increment PRIMARY KEY" }
  56           types[:bigint_auto_64] = { :name => "bigint(64) DEFAULT NULL auto_increment" }
  57           types[:bigint_auto_11] = { :name => "bigint(11) DEFAULT NULL auto_increment" }
  58           types[:bigint_auto_20] = { :name => "bigint(20) DEFAULT NULL auto_increment" }
  59           types[:four_byte_unsigned] = { :name=> "integer unsigned" }
  60           types[:inet] = { :name=> "integer unsigned" }
  61
  62           enumerations.each do |e,v|
  63             types[e.to_sym]= { :name => "enum('#{v.join '\',\''}')" }
  64           end
  65
  66           types
  67         end
  68
  69         def change_column(table_name, column_name, type, options = {})
  70           unless options_include_default?(options)
  71             options[:default] = select_one("SHOW COLUMNS FROM #{table_name} LIKE '#{column_name}'")["Default"]
  72
  73             unless type == :string or type == :text
  74               options.delete(:default) if options[:default] = "";
  75             end
  76           end
  77
  78           change_column_sql = "ALTER TABLE #{table_name} CHANGE #{column_name} #{column_name} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
  79           add_column_options!(change_column_sql, options)
  80           execute(change_column_sql)
  81         end
  82
  83         def myisam_table
  84           return { :id => false, :force => true, :options => "ENGINE=MyIsam" }
  85         end
  86
  87         def innodb_table
  88           return { :id => false, :force => true, :options => "ENGINE=InnoDB" }
  89         end
  90
  91         def innodb_option
  92           return "ENGINE=InnoDB"
  93         end
  94
  95         def change_engine (table_name, engine)
  96           execute "ALTER TABLE #{table_name} ENGINE = #{engine}"
  97         end
  98
  99         def add_fulltext_index (table_name, column)
 100           execute "CREATE FULLTEXT INDEX `#{table_name}_#{column}_idx` ON `#{table_name}` (`#{column}`)"
 101         end
 102
 103         def enumerations
 104           @enumerations ||= Hash.new
 105         end
 106
 107         def create_enumeration (enumeration_name, values)
 108           enumerations[enumeration_name] = values
 109         end
 110
 111         def drop_enumeration (enumeration_name)
 112           enumerations.delete(enumeration_name)
 113         end
 114
 115         def alter_primary_key(table_name, new_columns)
 116           execute("alter table #{table_name} drop primary key, add primary key (#{new_columns.join(',')})")
 117         end
 118
 119         def interval_constant(interval)
 120           "'#{interval}'"
 121         end
 122       end
 123     end
 124
 125     if defined?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
 126       class PostgreSQLAdapter
 127         alias_method :old_native_database_types, :native_database_types
 128
 129         def native_database_types
 130           types = old_native_database_types
 131           types[:double] = { :name => "double precision" }
 132           types[:integer_pk] = { :name => "serial PRIMARY KEY" }
 133           types[:bigint_pk] = { :name => "bigserial PRIMARY KEY" }
 134           types[:bigint_pk_64] = { :name => "bigserial PRIMARY KEY" }
 135           types[:bigint_auto_64] = { :name => "bigint" } #fixme: need autoincrement?
 136           types[:bigint_auto_11] = { :name => "bigint" } #fixme: need autoincrement?
 137           types[:bigint_auto_20] = { :name => "bigint" } #fixme: need autoincrement?
 138           types[:four_byte_unsigned] = { :name => "bigint" } # meh
 139           types[:inet] = { :name=> "inet" }
 140
 141           enumerations.each_key do |e|
 142             types[e.to_sym]= { :name => e }
 143           end
 144
 145           types
 146         end
 147
 148         def myisam_table
 149           return { :id => false, :force => true, :options => ""}
 150         end
 151
 152         def innodb_table
 153           return { :id => false, :force => true, :options => ""}
 154         end
 155
 156         def innodb_option
 157           return ""
 158         end
 159
 160         def change_engine (table_name, engine)
 161         end
 162
 163         def add_fulltext_index (table_name, column)
 164           execute "CREATE INDEX #{table_name}_#{column}_idx on #{table_name} (#{column})"
 165         end
 166
 167         def enumerations
 168           @enumerations ||= Hash.new
 169         end
 170
 171         def create_enumeration(enumeration_name, values)
 172           enumerations[enumeration_name] = values
 173           execute "CREATE TYPE #{enumeration_name} AS ENUM ('#{values.join '\',\''}')"
 174         end
 175
 176         def drop_enumeration(enumeration_name)
 177           execute "DROP TYPE #{enumeration_name}"
 178           enumerations.delete(enumeration_name)
 179         end
 180
 181         def rename_enumeration(old_name, new_name)
 182           execute "ALTER TYPE #{quote_table_name(old_name)} RENAME TO #{quote_table_name(new_name)}"
 183         end
 184
 185         def alter_primary_key(table_name, new_columns)
 186           execute "ALTER TABLE #{table_name} DROP CONSTRAINT #{table_name}_pkey"
 187           execute "ALTER TABLE #{table_name} ADD PRIMARY KEY (#{new_columns.join(',')})"
 188         end
 189
 190         def interval_constant(interval)
 191           "'#{interval}'::interval"
 192         end
 193
 194         def add_index(table_name, column_name, options = {})
 195           column_names = Array(column_name)
 196           index_name   = index_name(table_name, :column => column_names)
 197
 198           if Hash === options # legacy support, since this param was a string
 199             index_type = options[:unique] ? "UNIQUE" : ""
 200             index_name = options[:name] || index_name
 201             index_method = options[:method] || "BTREE"
 202           else
 203             index_type = options
 204           end
 205
 206           quoted_column_names = column_names.map { |e| quote_column_name(e) }
 207           if Hash === options and options[:lowercase]
 208             quoted_column_names = quoted_column_names.map { |e| "LOWER(#{e})" }
 209           end
 210           quoted_column_names = quoted_column_names.join(", ")
 211
 212           execute "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} USING #{index_method} (#{quoted_column_names})"
 213         end
 214       end
 215
 216       def rename_index(table_name, old_name, new_name)
 217         execute "ALTER INDEX #{quote_table_name(old_name)} RENAME TO #{quote_table_name(new_name)}"
 218       end
 219
 220       def rename_sequence(table_name, old_name, new_name)
 221         execute "ALTER SEQUENCE #{quote_table_name(old_name)} RENAME TO #{quote_table_name(new_name)}"
 222       end
 223     end
 224   end
 225 end