Bases de datos con

Django II
 Configurar gestores bases de datos

En la clase anterior creamos algunas tablas y realizamos consultas básicas. Sin

embargo, trabajamos con el gestor SQLite3, el cual es el gestor de bases de datos que
maneja Django por defecto, y aunque SQLite es bastante común; en el ámbito laboral son
usados una gran cantidad gestores diferente, por lo tanto, es muy probable que en
algún momento debamos hacer uso de uno diferente.
La gran mayoría de los gestores hace uso de el lenguaje SǪL como lenguaje de manejo de datos, y a pesar
de que todos utilicen el mismo lenguaje existe pequeñas variaciones de sintaxis entre cada gestor.

Django tiene la ventaja de ahorrarnos esas variaciones en la sintaxis SǪL, ya que sólo debemos configurar
el gestor que usaremos en nuestro proyecto y al momento de utilizar la clase “Model” de Django esta se
encargara de generar la instrucción SǪL correcta para el gestor que configuramos.

SǪLite es un gestor que funciona muy bien con Django, y es el gestor que viene por defecto debido que
este es muy liviano. No obstante, por motivos de seguridad, compatibilidad con Django y rendimiento
cuando la base de datos es grande, el gestor recomendado para usar con Django es PostgreSǪL.
En la clase de hoy configuraremos este gestor, sin embargo, la configuración de cualquier otro es muy
similar. También debemos tener en cuenta que usar un gestor diferente no cambiará la manera de trabajar
en Django, solo deberemos realizar algunas configuraciones adicionales.
Primero ingresaremos en la página https://www.postgresql.org, cliquearemos en
“Download” elegiremos el sistema operativo, y por último descargaremos el instalador.
Una vez termine la descarga, ejecutamos el instalador y sólo nos limitaremos a oprimir siguiente hasta que
lleguemos a esta ventana, acá colocaremos una contraseña que podemos recordar fácilmente. Es
importante recordar esta contraseña a que el gestor nos la pedirá y también será necesaria para la
configuración en Django.
Luego de ingresar la contraseña nos aparecerá la ventana donde podemos indicar el puerto que usará la
aplicación para la conexión, por defecto PostgreSǪL utiliza el 5432. Este numero de puerto es importante
recordarlo ya que será necesario al momento de la configuración en Django
Una vez ingresamos la contraseña y el puerto, haremos click en siguiente hasta que comience la
instalación. Una vez terminada becaremos el programa “pgAdmin4” e ingresaremos, nos aparecerá una
ventana la cual nos pedirá que ingresemos la contraseña que especificamos cuando instalamos el
programa. Es posible que nos pida varias veces esta contraseña, así que es realmente importante no
olvidarla.
Si desplegamos la pestaña con el nombre “Servers” veremos ya existe una base de datos,
esta es generada por el programa, pero crearemos nuestra propia base de datos
Para crear una nueva base de datos sólo debemos oprimir click derecho sobre “Databases” y seleccionar
“créate”. Luego nos aparecerá una ventana en la cual colocamos el nombre. Es posible cambiar el usuario
en el campo “Owner”, el usuario que coloquemos en este campo también es necesario para la
configuración en Django. En esta ocasión es recomendable mantener el usuario predeterminado luego de
colocar el nombre oprimimos el botón “Save”.
Observemos que ahora tenemos dos bases de datos, sin embargo, la nuestra no
tiene tablas. Ahora debemos conectar a Django con esta nueva base de datos. Y repetir
que realizamos en la clase pasada con SQLite3 para realizar la migración y crear
nuestras tablas
Como es costumbre comenzaremos entrando al CMD y activar anaconda con el comando “conda actívate
base”. Luego nos situaremos en la carpeta de nuestro proyecto con la instrucción “cd”.
Antes de comenzar con la configuración de nuestra base de datos PostgreSǪL necesitaremos instalar la
librería “psycopg2”, solo debemos escribir el comando “pip install psycopg2”. Ahora comenzaremos con la
configuración:
Primero debemos dirigirnos al documento “settings.py” y buscaremos la lista que tiene como nombre
“DATABASES”. Si nos fijamos dentro en esta lista encontraremos un diccionario que contiene la
configuración para la base de datos SǪLite3, la cual Django configuró automáticamente.
En el diccionario cambiaremos el valor de las llaves “ENGINE” y “NAME”, además agregaremos las tuplas
“USER”, “PASSWORD”, “HOST” y “DATABASE_PORT”

• ENGINE: Gestor de base de datos que estemos usando.

• NAME: nombre de la base de datos.
• USER: usuario de la base de datos, este gestor usa por defecto ‘postgres’ como usuario
• PASSWORD: La contraseña que colocamos cuando estábamos instalando postgre.
• HOST: La dirección del HOST donde se encuentra alojada nuestra base de datos, en este caso como
esta alojada en de forma local podemos colocar la dirección del localhost “127,0,0,1” o “localhost/”
• DATABASE_PORT: El puerto que especificamos cuando instalamos este gestor
Así de fácil se configura un gestor de base de datos en Django. Ahora debemos repetir el proceso que
realizamos en la clase pasada con SǪLite3 para realizar las migraciones y crear las tablas para que quede
listo para funcionar:
Primero, estando situados en la carpeta de nuestro proyecto escribiremos en consola “Python manage.py
makemigration” como estamos trabajando con el mismo “Model” de la clase pasada y no hemos hecho
cambio en el nos indicara que no se detectaron cambios:
Ahora para ejecutar la migración escribiremos en la consola “Python manage.py migrate” y observemos que
la migración se realizo sin errores
Si vamos a nuestro gestor y a nuestra base de datos le hacemos un “Regresh” podemos
observar que ya aparecen las tablas que crea Django junto con las que creamos con el
“model”.
En el gestor podemos inspeccionar nuestras tablas en este caso, esta totalmente vacía. Sólo a modo
informativo en la parte superior de la ventana nos aparece la instrucción SǪL necesaria para extraer
todos los registros de nuestra tabla:
La manera de ingresar registros es exactamente igual que en clases anterior. En la consola activaremos el
Shell con “Python manage.py Shell” luego importamos la tabla “from gestor.models import articulo” y por
último realizamos la inserción del registro
Revisamos nuestro gestor observemos que esta el registro que acabamos de ingresar. Como mencionamos
al comienzo de la clase, sin importar que gestor usemos el “model” de Django generará la instrucción
correcta para el gestor que nosotros hemos configurado.
En clases pasada hicimos algunas consultas simples, ahora veamos como
realizar consultas con criterios en Django.

Primero agregaremos algunos registros nuevos

var1=articulo.objects.create(nombre='silla', seccion='hogar', precio=200)

var1=articulo.objects.create(nombre='Zapatos', seccion='caballero', precio=500)

var1=articulo.objects.create(nombre='balon', seccion='deporte', precio=160)

var1=articulo.objects.create(nombre='falda', seccion='damas', precio=800)

var1=articulo.objects.create(nombre='taladro', seccion='ferreteria', precio=1600)

var1=articulo.objects.create(nombre='raqueta', seccion='deporte', precio=230)

var1=articulo.objects.create(nombre='destornillador', seccion='ferreteria', precio=230)

var1=articulo.objects.create(nombre='mesa', seccion='hogar', precio=380)

var1=articulo.objects.create(nombre='silla', seccion='gamer', precio=470)

Este sería el resultado. Ahora realicemos una consulta que me devuelva
todos los artículos que sean de la sección “ferretería”
Esta consulta se realiza de la siguiente manera:

articulo.objects.filter(sección=‘ferreteria’)

Podemos observar que la consulta nos devolvió 2 objetos y nos indica que un objeto tiene la clave (5) y el
otro (7) y si nos fijamos en nuestra tabla, efectivamente los registro con la llave principal 5 y 7 son los que
pertenecen a la sección de ferretería. Sólo tenemos un problema, la consulta nos devolvió dos objetos
dentro de un “ǪuerrySet” y la información no se muestra no es legible.
Para que la información se muestre de una manera legible, debemos transformar los objetos dentro de la
ǪuerySet en una cadena de texto. Ya que estamos trabajando con la tabla “articulo” dentro de la clase
“articulo” crearemos la función que realice este procedimiento de la siguiente manera.

def str (self):

return 'Articulo: %s, Precio: %s, Seccion: %s' %(self.nombre, self.precio, self.seccion)
La función ya esta lista, sin embargo, si intentamos repetir la consulta no entregará la misma respuesta
que nos entrego anteriormente, ya que cada vez que realizamos un cambio en el archivo “model”
debemos realizar de nuevo las migraciones para que los cambios surtan efecto. Primero debemos salir
del Shell escribiendo el comando “exit()” volviendo a la carpeta raíz del proyecto.

Ya podemos hacer las migraciones usando los comandos “python manage.py makemigrations” y “Python
manage.py migrate”
Aunque nos diga que no se han detectado cambios y que no se ha aplicado la migración, cada vez que
escribamos código nuevo en el “model” debemos realizar nuevamente las migraciones.

Ahora sólo resta ingresar nuevamente al Shell, realizar de nuevo la importación de la clase artículo y repetir
la consulta.

Observem os que ahora la in formación se m ues tra como especificamos en la fu nción y los datos
corresponden con los registros en nuestra base de datos:
También podemos agregar mas filtros. Nuestra tabla contiene dos registros con el nombre “silla” por lo tanto
si en el filtro especificamos que nos devuelva la información de los registros con el nombre “silla” nos
devolverá ambos registros como es de esperar. Pero si agregamos otro filtro mas como ejemplo la sección
“gamer” solamente nos devolverá los registros llamados “silla” y que la sección sea “gamer”.

Podemos agregar tantos filtros como queramos:

Otros criterios de consulta muy comúnmente utilizado son los “mayor o igual que” y “menor o igual que”.

Tal vez intuyamos que la manera de indicar estos criterios es usando la sintaxis “>=“ o “<=” y estaríamos
en lo correcto, sin embargo, en el Shell estos símbolos tienen otra función por lo tanto si intentamos
usarlos nos aparecerá un error, sólo en esta oportunidad que estamos en el shell debemos sustituir “>=”
por “__gte” y “<=“ por “__lte”, sólo será necesario sustituir los símbolos cuando estemos en el ámbito del
Shell:
En la consulta obtendremos todos los registros cuyo precio sea mayor o
igual a 500
Y como podemos intuir podemos realizar consultas con un rango de valores como criterio, por ejemplo,
obtengamos todos los productos con precios que estén en un rango mayor o igual a 300 y menor o igual a
700
Y como es de esperar, también podemos combinar criterios “igual que”, por ejemplo busquemos los
artículos donde el precio sea mayor a 220 y menor a 800 que pertenezcan a la sección “ferreteria”.
Notemos que el “mayor que” es __gt mientras que el “mayor o igual que” es __gte.
La sintaxis para realizar una consulta “OR” es un poco distinta, ya que podíamos verla como escribir dos
consultas a la vez, separadas por una barra (|). Para ejemplificar realizaremos una consulta que nos
muestre los datos de los registros cuya sección sea “hogar” o “deporte”
Y como es de esperar también podemos combinarlas con criterios “mayor que”. Como ejemplo, realicemos
una consulta que nos devuelva los registros donde el precio sea mayor a 200 y la sección sea “deporte” o
“hogar”