Rails Schema創建問題

Question

我正在使用Jruby和rails 2.2.2。我的問題是我有一個沒有正確寫入數據庫模式的遷移。

這裏是我的移民：

class CreateNotes < ActiveRecord::Migration 
    def self.up 
    create_table(:notes, :options => 'ENGINE=MyISAM') do |t| 
     t.string :title 
     t.text :body 

     t.timestamps 
    end 

    execute "alter table notes ADD FULLTEXT(title, body)" 

end 

這裏是它產生於schema.rb

create_table "notes", :force => true do |t| 
    t.string "title" 
    t.text  "body" 
    t.datetime "created_at" 
    t.datetime "updated_at" 
end 

add_index "notes", ["title", "body"], :name => "title" 

我有兩個問題：

• 我如何'ENGINE=MyISAM'成架構？
• 爲什麼我的執行語句變成add_index "notes", ["title", "body"], :name => "title"？以及如何強制遷移將其作爲執行聲明？

感謝Christian Lescuyer的回答。但是，當我嘗試這個沒有改變。我取消了config.active_record ...行的註釋，但是，我的模式沒有改變。我已經在jruby和ruby 1.8.6上用rails 2.2.2和edge rails試過了，並且架構沒有改變。有人可以告訴我我做錯了什麼嗎？

Answer 1

由於我使用外鍵約束，我使用SQL格式進行遷移。在的environment.rb：

# Use SQL instead of Active Record's schema dumper when creating the test database. 
# This is necessary if your schema can't be completely dumped by the schema dumper, 
# like if you have constraints or database-specific column types 
config.active_record.schema_format = :sql 

Answer 2

基督教是正確的。

做

config.active_record.schema_format =：SQL

在environment.rb中

但你必須使用一個不同的模式轉儲文件格式和文件位置。嘗試做你的遷移和尋找「schema.sql文件」，而不是scehema.rb

所有這一切的原因是，該計劃文件的點是不特定數據庫（適用於所有類型的數據庫）文件。所以當你使用通過unsupoorted執行語句只能在mysql上工作的功能時，它們不能被拉入schema.rb

Answer 3

我也希望看到一個新的.sql文件出現在「rake db：migrate」 ，一旦我設置

config.active_record.schema_format = :sql 

in config/environment.rb。

然而，顯然這不是它的工作原理。我必須這樣做明確獲得DB/[發展|考試|生產] _structure.sql文件：

rake db:structure:dump 

Answer 4

要使用SQL變種進行測試（而不是schema.rb），你需要使用

耙分貝：測試：clone_structure

我們的架構使用的UUID（UUID寶石），也紅山on Rails的（RHoR）不錯FK插件。不幸的是，FK需要PK，只能在遷移中使用EXECUTES添加。

衆所周知，這些執行不會使schema.rb;然而，很難找到db：rake替代方法：test：爲不能使用schema.rb的應用程序做準備。

Answer 5

只是針對那些Rails 3（測試版4，目前）的更新 - Christian的解決方案仍然是正確的，只有正確放置該行的地方在config/application.rb，Application類的範圍內，應該在以您的Rails項目命名的模塊。

Answer 6

下面的monkeypatch解決了您的模式自卸器（Rails 3.2）的FULLTEXT索引問題和數據庫引擎選項。你可以把它放在config/initializers/（例如schema_dumper_monkeypatch.rb）：

module ActiveRecord 
    class SchemaDumper 
    def table(table, stream) 
     columns = @connection.columns(table) 
     begin 
     tbl = StringIO.new 

     # first dump primary key column 
     if @connection.respond_to?(:pk_and_sequence_for) 
      pk, _ = @connection.pk_and_sequence_for(table) 
     elsif @connection.respond_to?(:primary_key) 
      pk = @connection.primary_key(table) 
     end 

     tbl.print " create_table #{remove_prefix_and_suffix(table).inspect}" 
     if columns.detect { |c| c.name == pk } 
      if pk != 'id' 
      tbl.print %Q(, :primary_key => "#{pk}") 
      end 
     else 
      tbl.print ", :id => false" 
     end 
     tbl.print ", :force => true" 

     # Add table engine 
     res = @connection.execute "SHOW TABLE STATUS LIKE '#{table}'" 
     engine = res.first[res.fields.index("Engine")] rescue nil 
     tbl.print ", :options => 'ENGINE=#{engine}'" if engine 
     res = nil # Free the result   

     tbl.puts " do |t|" 

     # then dump all non-primary key columns 
     column_specs = columns.map do |column| 
      raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" if @types[column.type].nil? 
      next if column.name == pk 
      spec = {} 
      spec[:name]  = column.name.inspect 

      # AR has an optimization which handles zero-scale decimals as integers. This 
      # code ensures that the dumper still dumps the column as a decimal. 
      spec[:type]  = if column.type == :integer && [/^numeric/, /^decimal/].any? { |e| e.match(column.sql_type) } 
           'decimal' 
          else 
           column.type.to_s 
          end 
      spec[:limit]  = column.limit.inspect if column.limit != @types[column.type][:limit] && spec[:type] != 'decimal' 
      spec[:precision] = column.precision.inspect if column.precision 
      spec[:scale]  = column.scale.inspect if column.scale 
      spec[:null]  = 'false' unless column.null 
      spec[:default] = default_string(column.default) if column.has_default? 
      (spec.keys - [:name, :type]).each{ |k| spec[k].insert(0, "#{k.inspect} => ")} 
      spec 
     end.compact 

     # find all migration keys used in this table 
     keys = [:name, :limit, :precision, :scale, :default, :null] & column_specs.map{ |k| k.keys }.flatten 

     # figure out the lengths for each column based on above keys 
     lengths = keys.map{ |key| column_specs.map{ |spec| spec[key] ? spec[key].length + 2 : 0 }.max } 

     # the string we're going to sprintf our values against, with standardized column widths 
     format_string = lengths.map{ |len| "%-#{len}s" } 

     # find the max length for the 'type' column, which is special 
     type_length = column_specs.map{ |column| column[:type].length }.max 

     # add column type definition to our format string 
     format_string.unshift " t.%-#{type_length}s " 

     format_string *= '' 

     column_specs.each do |colspec| 
      values = keys.zip(lengths).map{ |key, len| colspec.key?(key) ? colspec[key] + ", " : " " * len } 
      values.unshift colspec[:type] 
      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  

    def indexes(table, stream) 
     if (indexes = @connection.indexes(table)).any? 
     add_index_statements = indexes.map do |index| 

      if index.name =~ /fulltext/i 
      " execute \"CREATE FULLTEXT INDEX #{index.name} ON #{index.table} (#{index.columns.join(',')})\"" 
      elsif index.name =~ /spatial/i 
      " execute \"CREATE SPATIAL INDEX #{index.name} ON #{index.table} (#{index.columns.join(',')})\"" 
      else 
      statement_parts = [ 
       ('add_index ' + remove_prefix_and_suffix(index.table).inspect), 
       index.columns.inspect, 
       (':name => ' + index.name.inspect), 
      ] 
      statement_parts << ':unique => true' if index.unique 

      index_lengths = (index.lengths || []).compact 
      statement_parts << (':length => ' + Hash[index.columns.zip(index.lengths)].inspect) unless index_lengths.empty? 

      index_orders = (index.orders || {}) 
      statement_parts << (':order => ' + index.orders.inspect) unless index_orders.empty? 

      ' ' + statement_parts.join(', ') 
      end 
     end 

     stream.puts add_index_statements.sort.join("\n") 
     stream.puts 
     end 
    end 
    end 
end