fcbk
Conéctate con TwitterConéctate con Facebook
9

Conectar una base de datos desde Ruby

0Puntos

hace 2 meses

A todo el que ha iniciado en Ruby on Rails le han dicho que uno de los pasos iniciales es crear la base de datos. Esto se hace con el comando rake db:create con el que se corre una tarea para crear nuestra base de datos. Otro paso es que se corran todas las migraciones que tenemos pendientes para nuestro proyecto, así que el siguiente comando a correr es rake db:migrate.

Te preguntaste alguna vez, ¿cómo funcionan estos comandos? En este post podrás hacer tu propia integración con una base de datos desde Ruby, sin necesidad de descargar todo el stack de rails.

¿Qué se necesita antes de empezar?

Para el ejemplo que vamos a utilizar para explicar cómo se realiza la conexión con una base de datos, lo haremos con postgresql. Para ello necesitas tener instaladas algunas herramientas:

  • Postgresql (recuerda el usuario y contraseña al momento de configurar Postgres)
  • Ruby
  • Gemas adicionales:
    • gem install pg
    • gem install activerecord

Nota: En Ruby, a las librerías que se utilizan en un proyecto se les llama gemas.

Conexión con una base de datos

Antes de iniciar: como ya tienes instalado Postgres, verifica que el servicio esté corriendo. En linux, puedes hacerlo con sudo service postgres status.

Todo nuestro ejemplo lo probemos desde la consola de ruby, para ello ingresas con el comando irb:

  • Primero necesitamos tener guardada nuestra configuración con la base de datos:
# Guardaremos toda nuestra configuración en forma de un hash en una variable en ruby
db_config = {
	host:'localhost',
	adapter:'postgresql',
	encoding:'utf-8',
	database:'postgres',
	schema_search_path:'public'
}

El nombre de la base de datos que estoy guardando en la configuración, es ‘postgres’ debido a que al iniciar con Postgres siempre tenemos esta base de datos creada.

Recuerda que al instalar Postgres configuraste un usuario y una contraseña. Entonces para realizar la conexión con Postgres es necesario que se agregue el username y la contraseña dentro de nuestro hash de configuración, lo puedes hacer de la siguiente forma:

db_config = db_config.merge({username:'usuario_postgres', password:'password_postgres'})

Para conectarnos con nuestra base de datos debemos llamar al método establish_connection de active_record:

# Primero llamamos a las gemas de postgres y active_record# En ruby, para llamar a una gema usamos la palabra requirerequire'pg'require'active_record'# Ahora sí utilizamos nuestra conexiónActiveRecord::Base.establish_connection(db_config)

Con esto, tenemos una conexión con postgres:

Crear una base de datos

Una vez establecida nuestra conexión con postgres, podemos crear una base de datos nueva:

# Primero configuremos el nombre de la base de datos en nuestro hash de configuración
db_config[:database] = 'blog'# El nombre de mi base de datos de ejemplo será blogActiveRecord::Base.connection.create_database(db_config[:database])

Si quieres verificar si realmente creó la base de datos llamada blog, puedes entrar desde postgres y listar las base de datos creadas.

Cambios en nuestra base de datos (migraciones)

En Ruby, bueno en Rails, los cambios en la base de datos se van guardando en archivos y se les llama migraciones. Los migraciones pueden ser: crear o eliminar una tabla, agregar o eliminar atributos de una tabla. Las migraciones son importantes porque guardan una historia de la base de datos y nos permiten regresar a una migración en específico, esto nos sirve para poder volver a una versión estable cuando hemos agregado bugs en nuestro proyecto.

Las migraciones tienen una forma de escribirse, además de incluir métodos especiales para hacer todas las modificaciones que se necesiten en nuestra base de datos. Este es un ejemplo de cómo crear una tabla llamada Posts (Publicaciones), la guardaremos en un archivo llamado 20170707151200_create_posts.rb.

classCreatePosts < ActiveRecord::Migration[5.0]defchange# create_table :posts crea una tabla llama posts en la base de datos
		create_table :postsdo |t|
			# t.string :title agrega un atributo llamado title de tipo string 
			t.string :title# t.text :content agrega un atributo llamado content de tipo text
			t.text :content# t.timestamps agrega 2 atributos created_at y updated_at que se agregar automáticamente al crear o actualizar un registro
			t.timestamps
		endendend

Otro ejemplo de migración será agregar un campo a la tabla que tenemos, esta la guardaremos con el nombre 20170707153200_add_user_name_to_posts.rb.

classAddUserNameToPosts < ActiveRecord::Migration[5.0]defchange
    add_column :posts, :user_name, :stringendend

La versión de active_record que estoy utilizando para el ejemplo es 5.0, nos ofrece el método change que indica el cambio que estamos realizando. En las versiones anteriores, se usaban dos métodos en cada migración eran up y down.

Existen muchas métodos de migración como los métodos create_table y add_column. Pueden revisar todos los métodos aquí: http://edgeguides.rubyonrails.org/active_record_migrations.html#using-the-change-method

Algo adicional que deberían saber es que rails tiene ciertas convenciones para darle los nombres a los archivos y clases. El nombre de archivos de migraciones suele ser explícito y en forma camel_case, por ejemplo create_posts.rb. Entonces, ¿qué son esos números que tienen delante el nombre de nuestros archivos de migración? Para que se reconozca el orden de la migración active_record necesita saber el tiempo exacto en el que fueron generados, así que antes del nombre que hayamos elegido, debemos escribir el año, mes, día, hora, minuto y segundo en el que fue creado con este formato YYYYMMDDHHMMSS.

Ambos archivos creados, los guardaremos en una carpeta que llamaremos migrations. Así ejecutamos todas las migraciones en un solo comando:

ActiveRecord::Migrator.migrate('migrations')

Con esto ya está creada la tabla posts y tiene 3 atributos creados.

Schema.rb
Para generar un archivo con la estructura de nuestra base de datos (tablas y atributos), debemos llamar al módulo schema_dumper:

# Llamar al módulo de active_recordrequire'active_record/schema_dumper'# Guardaremos el nombre del archivo en una variable
filename = "schema.rb"# Abrimos (o creamos si no existe) el archivo y escribimos sobre él
File.open(filename, "w:utf-8") do |file|
	# Con el método dump recolectamos la información de la base de datos creada y la guardamos en el archivoActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
end

¡Con esto tenemos todo listo! Ya sabes cómo conectar una aplicación en Ruby con una base de datos relacional. Recuerda que con active_record puedes conectarte casi con cualquier base de datos, lo único que cambia es la configuración inicial. Si quieres saber cómo hacer una aplicación web sólo con Ruby, puedes ingresar a platzi.com/ruby.

Kattya Daniella
Kattya Daniella