Merge branch 'master' into openstreetbugs
[rails.git] / 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