Tablas de ingeniería inversa (generación) o esquema de base de datos a partir de modelos y vistas en Ruby on Rails

Actualización: la pregunta aún está abierta, cualquier revisión, comentario siempre es bienvenido

Estoy teniendo proyecto de rieles existentes en el que algunos archivos y directorios importantes han sido perdida.

versión de project rails (2.3.8) lo encontré en environment.rb

actualmente lo que estoy teniendo es

app
   controllers (already fully coded)
   helpers  (already fully coded)
   models (already fully coded) 
   reports (already fully coded)
   views  (already fully coded)

config ---> default configurations (already fully coded)
lib ---> contains nothing
public --> contains images and scripts (already fully coded)
script ---> contains server,runner,plugin,dbconsole....

El directorio de la aplicación contiene completamente el estado de funcionamiento de los códigos, la aplicación/modelo contiene más de 100 archivos .rb, por lo que supongo que habrá más de 100 tablas.

las cosas que faltan principalmente son directorio db, archivo .gem, archivo rake, documento, prueba, proveedor, base de datos, esquema.rb y migraciones

Nota: no tengo el esquema de tabla y la base de datos para ese proyecto

necesito generar tablas o una base de datos completa a partir de modelos y vistas y estoy buscando cosas de ingeniería inversa para generar esquemas de base de datos a partir de modelos o vistas

Soy un novato en Rails y soy de Java, en Java al usar Hibernate hay un pojo (modelo en Rails) para la opción de base de datos disponible, estoy buscando un tipo similar de material para Rails, y mi principal objetivo es ejecutar ese proyecto. , así que chicos por favor ayúdenme.

preguntado el 31 de julio de 12 a las 15:07

¿Tiene migraciones o schema.rb? Si no tiene nada de estos dos, entonces es realmente difícil identificar el esquema de las tablas sobre la base de los modelos. -

Qué mala suerte, perder la base de datos, el esquema y las migraciones; lástima que no perdiste el script y retuviste uno de esos. Debo admitir que tengo curiosidad de cómo sucede algo así, apuesto a que es una historia interesante... -

3 Respuestas

Para recrear el esquema de la base de datos, tomará bastante tiempo.

Puede obtener mucha información sobre la base de datos en el directorio app/models, app/controllers app/views.

Debes saber que ActiveRecord no requieren que enumere explícitamente todos los atributos de un modelo. Esto tiene implicaciones importantes: sólo puede inferir ¡Qué atributos aún tiene que agregar a la base de datos, en función de si se hace referencia a un atributo! Esto significa que hacer esto será un ARTE. Y no hay pasos CLAROS para completar este trabajo. Pero a continuación hay algunas reglas que puedes usar para AYUDARTE.

Este es un proyecto GRANDE, a continuación hay pautas, reglas y consejos para ayudarlo.. Pero tenga en cuenta que esto podría tomar un Corto tiempo, y ser frustrante a veces para hacer esto.


Qué tablas necesitas:

Cada tabla normalmente tendrá una coincidencia ActiveRecord :: Base modelo. Entonces, en el directorio de aplicaciones/modelos, verifique cada archivo y, si la clase hereda de ActiveRecord::Base, es una tabla adicional.

El nombre de la tabla es, por defecto, una versión en mayúsculas y minúsculas del nombre de la clase.

class UserGroup < ActiveRecord::Base # for this class

el nombre de la tabla es user_groups. Fíjese que es plural, y en lugar de camello, está en minúsculas, con guiones bajos para separar las palabras.

Todas estas tablas tendrán una columna de enteros "id". De forma predeterminada, las tablas también tienen una columna "created_at" y "updated_at" de tipo datetime.

Asociaciones y claves foráneas:

Puede inferir qué claves externas existen por las asociaciones en los Modelos. Todas las asociaciones se enumeran explícitamente, por lo que esto no es demasiado difícil.

Por ejemplo:

class UserGroup < ActiveRecord::Base # for this class
  belongs_to :category

Esto significa que la tabla user_groups tiene una columna denominada "category_id", que es una clave externa para la tabla de categorías.

Esto significa que el modelo de categoría probablemente tenga una relación inversa (pero no una columna adicional):

class Category < ActiveRecord::Base
  has_many :user_groups

La otra asociación principal es la asociación has_many_and_belongs_to. P.ej.

class A < ActiveRecord::Base
  has_and_belongs_to_many :bs
end
class B < ActiveRecord::Base
  has_and_belongs_to_many :as
end

Esto significa que hay una tabla de combinación para agregar llamada "as_bs" (as y bs se ordenan alfabéticamente), con las claves externas "a_id" y "b_id".

Todas las claves foráneas son números enteros.


Atributos

Ok, esas son las asociaciones de tablas. Ahora para los atributos normales...

Deberías revisar el aplicación/vistas/grupos_de_usuarios/ u otro similar aplicación / vistas directorios.

Dentro encontrará las plantillas de vista. Debe mirar las plantillas _form.html.erb (suponiendo que sean plantillas .erb, de lo contrario podrían ser plantillas .haml, etc.).

La plantilla _form.html.erb, si existe, normalmente tendrá muchos de los atributos enumerados como campos de formulario.

En la pestaña form_for bloquear, mira si dice algo como f.text_field :name, significa que hay un atributo/(columna en la tabla) llamado "nombre". Puede inferir de qué tipo debe ser la columna según el tipo de campo que sea. P.ej. en este caso, es una cadena, por lo que quizás sea apropiado un VARCHAR(255) (denominado cadena en Rails).

Es posible que también deba inferir qué tipo es apropiado en función del nombre del atributo (por ejemplo, si menciona algo como :hora, probablemente sea del tipo Hora o FechaHora).

Esto puede proporcionarle todos los demás atributos de la tabla. Pero en algunos casos, es posible que pase por alto los atributos. Si encuentra una referencia a otros atributos en el controlador, p. app/controllers/user_groups_controller.rb, entonces debe agregar eso como una columna en su tabla. Sin embargo, puede dejar esto hasta el final cuando lo pruebe, porque cuando lo prueba, si falta un atributo, arrojará un NoMethodError para el objeto del modelo relevante. P.ej. si dice que a la variable @user_group, de la clase UserGroup, le falta un método llamado título, entonces probablemente le falta una columna llamada "título" de tipo cadena.


Vuelva a crear su migración/base de datos

Bien, ahora sabe cuáles deberían ser las tablas de la base de datos y los nombres y tipos de columnas.

Debe generar/recrear una migración para su base de datos.

Para hacer esto, simplemente use el comando rails generate migration RecreateTables.

Entonces deberías encontrar un archivo en db/migrate/???_recreate_tables.rb.

En el interior, comience a escribir código Ruby para crear sus tablas. La referencia para esto se puede encontrar en http://guides.rubyonrails.org/migrations.html.

Pero esencialmente, tendrás algo como:

class RecreateTables < ActiveRecord::Migration
  def up
    create_table :user_groups do |t|
      t.string :name # adds a string (VARCHAR) column called "name"
      t.text :description # adds a textarea type column called "description
      t.timestamps # adds both "created_at" and "updated_at" columns for you
    end
  end

  def down
    drop_table :products # this is the reverse commands to undo stuff in "up"
  end
end

Para recrear su Gemfile:

Comience agregando un Gemfile predeterminado. Esto se puede hacer usando rails new testapplication en algún lugar para crear una aplicación de rieles vacía. Luego copie el Gemfile a su aplicación actual. Te ayudará a comenzar incluyendo rieles y otras gemas comunes.

Es MUY difícil determinar exactamente qué gemas se necesitan. Lo mejor que puede hacer es intentar agregarlos uno por uno mientras mira el código.

De nuevo, aquí, los errores de MethodNotFound son tus AMIGO. Cuando pruebe la aplicación, en función de las gemas que haya agregado, es posible que detecte algunos métodos faltantes que podrían proporcionar las gemas. Algunos métodos faltantes en los modelos pueden indicar gemas faltantes (o pueden indicar campos/columnas faltantes en la base de datos). Sin embargo, los métodos faltantes en las clases Controller o ActiveRelation son MUY probables debido a la falta de gemas.

Tendrá que revisar el código e intentar inferir qué gemas agregar.

Si utiliza métodos como can, can?, y tiene un archivo app/models/ability.rb, entonces necesitas gem 'cancan'. si llama devise en un modelo, necesita gem 'devise'. Muchas gemas comunes se pueden ver en http://ruby-toolbox.com.

Después de agregar gemas a su Gemfile, debe ejecutar bundle en su línea de comando para instalar las nuevas gemas antes de volver a probar. Cuando vuelva a probarlo, debe reiniciar su servidor de prueba. Repetición bundle exec rails server para iniciar un servidor de prueba local en localhost:3000 o algo así.

Simplemente puede copiar el Rakefile de rails new testapp, y lo hará probablemente incluye todo lo que necesitas.

Pruebas faltantes

El directorio test/ faltante no es relevante para su aplicación real. No es necesario para ejecutar la aplicación. Sin embargo, contiene scripts automáticos para probar su aplicación. Tendrá que volver a escribir nuevas pruebas si desea probar automáticamente su aplicación. Sin embargo, con el fin de recuperar su aplicación, puede ignorarla por ahora.

Falta el directorio de proveedores

Algunos códigos adicionales no se instalan como una joya, sino como un complemento. Cualquier cosa instalada como complemento se pierde si no tiene el directorio de proveedores. Al igual que con las gemas, lo mejor que puede hacer es tratar de inferir lo que podría faltar y volver a descargar el complemento que falta, ya sea reinstalando el complemento o usando un reemplazo de gema.


Consejos adicionales:

  • Intente leer algunos de los comentarios que podrían nombrar algunas de las gemas utilizadas.

  • Si falta un método o un conjunto de métodos que cree que no son campos/columnas de la base de datos, es posible que se deba a que falta una gema. Lo mejor que puede hacer es buscar en Google esos nombres de métodos. P.ej. si falta "paginar", puede buscar "rieles paginar gema" y ver qué gemas probables podría necesitar. Este ejemplo probablemente generará "will_paginate" y "kaminari". Luego tienes que intentar deducir cuáles de las gemas son necesarias. Tal vez hacer un grep will_paginate app -r en la línea de comando para ver si está usando paginate. El comando grep busca la cadena "will_paginate", en el directorio llamado "app", -r hace que haga esto recursivamente para todos los archivos

Respondido el 02 de Septiembre de 12 a las 04:09

Aunque Rails es un marco web de pila completa, también funcionaría sin algunas partes, si lo desea,

Ej: en tu caso

db - El directorio está ahí para mantener las migraciones para crear su base de datos/tablas, pero si está utilizando una base de datos heredada o los administradores de la base de datos manejan las cosas de la base de datos, es posible que no lo desee. (simplemente puede conectarse a la base de datos a través del archivo database.yml)

El archivo de gemas lo ayuda a mantener todas las gemas (bibliotecas) en un solo lugar como lo hace con Maven (en Java)

test, nuevamente, si terminó de escribir casos de prueba (lo cual es absolutamente una mala idea), ya necesita esto

vendedor, es para complementos de terceros y doc es para documentación, por lo que se aplica la misma regla, si ya los necesita, puede omitirlos

Hibernar en rieles llamado "Activerecord", el mismo concepto, un modelo se vincula con una tabla de base de datos (técnicamente, el modelo representa un bruto en la tabla)

Entonces, si realmente los quieres, agrégalos, pero si no, déjalos.

PERO, creo que tener un archivo Gem adecuado y casos de prueba es imprescindible.

bienvenido ven a Rails

HTH

Respondido 31 Jul 12, 15:07

A continuación, supongo que ya sabe cómo:

  • vuelca el esquema de tu base de datos en un archivo SQL
  • iniciar una consola de Rails (rails c)
  • generar una migración de Rails

Esto es lo que creo que deberías hacer.

  1. Identifique cuáles de sus clases corresponden a tablas físicas (menciona algunas vistas en su pregunta, lo que me lleva a creer que un subconjunto de sus modelos está vinculado a vistas de bases de datos en lugar de tablas reales). Para hacer esto, debe hacer coincidir las definiciones de sus modelos (clases que extienden ActiveRecord::Base) a CREATE TABLE declaraciones en su volcado de esquema. Por ejemplo, class Person en su código Ruby coincide con CREATE TABLE people en su volcado de esquema DB.

  2. Una vez que identificó esos modelos (nombres de clase), inicia una consola Rails y escribe esos nombres de modelo, uno a la vez, y presiona Enter. La salida de la consola para un modelo llamado Persona presumiblemente se vería así:

>> Person
=> Person(id: integer, first_name: string, last_name: string)

Luego tomas lo que está dentro de los paréntesis, quitas el encabezado id: integer,, deshazte de las comas, deshazte de los espacios en blanco después de los dos puntos, obteniendo así algo como esto:

first_name:string last_name:string

Habiendo hecho esto, el comando para generar la migración quedaría así:

rails g migration Person first_name:string last_name:string

Luego inicia un nuevo proyecto de Rails en otro lugar, realiza todas estas migraciones e inspecciona el contenido de db/migrate. Lo más probable es que sus migraciones estén hechas en un 90%, lo que aún debe hacer es reemplazar algunas instancias de t.integer con t.referencesy otras cosas menores que son completamente específicas del dominio e imposibles de capturar en una respuesta genérica.

HTH.

Respondido el 02 de Septiembre de 12 a las 10:09

¡Tu respuesta tiene un gran problema! No puede usar la consola de Rails para verificar los atributos en un modelo si la base de datos no está activa. ActiveRecord usa la tabla de la base de datos para inferir qué atributos hay en el modelo. Es por eso que no tiene que declarar cada atributo en la clase. - ronalchn

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.