ruby-on-rails - sirve - ruby on rails modelos

Problema de creación del esquema de Rails

Question

Estoy usando Jruby y Rails 2.2.2. Mi problema es que tengo una migración que no se está escribiendo correctamente en el esquema de la base de datos.

Aquí está mi migración:

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

Esto es lo que produce en 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"

Tengo dos preguntas:

• ¿Cómo obtengo ''ENGINE=MyISAM'' en el esquema?
• ¿Por qué mi sentencia de ejecución se convirtió en add_index "notes", ["title", "body"], :name => "title" ? y ¿cómo obligo a las migraciones a dejarlo como una instrucción de ejecución?

Gracias a Christian Lescuyer por la respuesta. Sin embargo, cuando probé esto, nada cambió. Descomenté la línea config.active_record ... pero mi esquema no ha cambiado. He intentado esto en jruby y en ruby ​​1.8.6 con rieles 2.2.2 y rieles laterales y no hay cambios en el esquema. ¿Alguien puede decirme qué estoy haciendo mal?

Answer 1

Como utilizo restricciones de clave externa, utilizo el formato SQL para migraciones. En 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

Christian tiene razón

hacer

config.active_record.schema_format =: sql

en environment.rb

pero luego debe usar un formato de volcado de esquema y una ubicación de archivo diferentes. intente hacer su migración y busque "schema.sql" en lugar de scehema.rb

El motivo de todo esto es que el punto del archivo de esquema es una base de datos no específica (funciona para todos los tipos de bases de datos). por lo tanto, cuando utiliza funciones que solo funcionan en mysql a través de una sentencia de ejecución no agrupada, no pueden ser calzados en schema.rb

Answer 3

Yo también esperaba ver un nuevo archivo .sql después de un "rake db: migrate", una vez que configuré

config.active_record.schema_format = :sql

en config / environment.rb.

Aparentemente, no es así como funciona, sin embargo. Debo hacer esto explícitamente para obtener un archivo db / [development | test | production] _structure.sql:

rake db:structure:dump

Answer 4

Para utilizar la variante SQL para probar (en lugar de schema.rb), deberá usar

rake db: test: clone_structure

Nuestro esquema usa UUID (uuid gem) y también el agradable FK plug-in de Red Hill on Rails (RHoR). Desafortunadamente, los FK requieren PK que solo se pueden agregar usando EJECUCIONES en las migraciones.

Es bien sabido que estos ejecutables no llegan a schema.rb; sin embargo, fue más difícil encontrar la alternativa de rake a db: test: prepararse para aplicaciones que no pueden usar schema.rb.

Answer 5

Solo una actualización para aquellos en Rails 3 (beta 4, actualmente) - La solución de Christian sigue siendo correcta, solo el lugar correcto para poner la línea es en config/application.rb , bajo el alcance de la clase Application , que debe definirse en una módulo nombrado después de su proyecto Rails.

Answer 6

El siguiente monkeypatch resuelve tanto el problema del índice FULLTEXT como la opción del motor de DB para su descargador de esquemas (Rails 3.2). Puedes ponerlo en config/initializers/ (ej. 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