15

Conectando aplicacion con base de datos relacional

primero que todo debemo crear nuestra base de datos, en este caso estare usando una base de datos local mysql llamada ejemplo que contiene 2 tablas:

Diagrama en blanco.png

luego debemos crear nuestra applicacion

/ejemplo
├── /app
│ ├── init.py
│ ├── models.py
│ ├── mysql_service.py
│ ├── /static
│ ├── /templates
│ └── config.py
├── main.py
└── start.sh

puedes dercargar este ejemplo y ver el paso a paso en github.
despues debemos instalar las dependecias, para este proyecto solo usaremos:

  • flask
  • mysqlclient
  • flask-SQLAlchemy
  • flask-marshmallow
    -marshmallow-SQLAlchemy

una vez instaladas las dependencias de la aplicacion, debemos configurarla en el archivo config.py; debemos configurar nuestra SECRET_KEY y nuestra SQLALCHEMY_DATABASE_URI, esta ultima dependerá de la base de datos que vayamos a usar:

postgres://username:[email protected]:port/databasemysql://username:[email protected]:port/databaseoracle://username:[email protected]:port/database

username: usuario de la base de datos
password: del usuario de la base de datos
host: 127.0.0.1 (localhost)
port: optional
database: nombre de la base de datos

Nuestro archivo config.py qudaria así:

classConfig:
    SECRET_KEY = 'SUPER_SECRETO'
    SQLALCHEMY_DATABASE_URI = 'mysql://sebastian:[email protected]/ejemplo'

y nuestro init.py quedaria asi:

from flask import Flask
from .config import Config

defcreate_app():
    app = Flask(__name__)
    app.config.from_object(Config)
    return app

ahora debemos establecer los modelos de nuestra base de datos vamos a nuestro archivo models.py:

from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()

classPersonas(db.Model):
    __tablename__ = 'personas'def__init__(self, id, nombre, apellido, locacion):
        self.id = id
        self.nombre = nombre
        self.apellido = apellido
        self.id_locacion = locacion

    id = db.Column(db.Integer, primary_key=True)
    nombre = db.Column(db.String(100), nullable=False)
    apellido = db.Column(db.String(100), nullable=True)
    id_locacion = db.Column(db.Integer, db.ForeignKey('locaciones.id'))

classLocaciones(db.Model):
    __tablename__ = 'locaciones'def__init__(self, id, ciudad, estado):
        self.id = id
        self.ciudad = ciudad
        self.estado = estado

    id = db.Column(db.Integer, primary_key=True)
    ciudad = db.Column(db.String(100), nullable=False)
    estado = db.Column(db.String(100), nullable=False)
    persona = db.relationship('Personas', backref='persona', lazy=True)

Es necesario que cada modelo tenga su propio constructor y ademas el id de cada tabla tenga el nombre “id”, ya que asi es como SQLAlchemy identifica la primary key. Es importante tambien definir las llaves foraneas y las relaciones, las relaciones nos permitiran hacer referencia desde locaciones hacia personas usando el backref.

Pero SQLAlchemy() recibe como parametro la aplicacion entonces debemos ir a nuestro init.py y pasrle la app, agragamos al codigo que ya tenemos:

from .models import db

#dentrodel metodo create app:
db.init_app(app)

una vez hecho esto ya estaremos listos para acceder a la información de nuestra base de datos. Vamos a mysql_service y aqui vamos a definir y declarar nuestras funciones : una para insertar otra para borrar y otra para consultar (query):

from .models import db, Personas, Locaciones

defintert_persona(id, nombre, apellido, locacion):
    persona = Personas(id, nombre, apellido, locacion)
    db.session.add(persona)
    db.session.commit()

defdelete_persona(id):
    persona = Personas.query.filter_by(id=id).first()
    db.session.delete(persona)
    db.session.commit()

defget_personas():
    persona = Personas.query.all()
    return persona

defget_persona(id):
    persona = Personas.query.filter_by(id=id).first()
    return persona

es importante importar los modelos y el objeto db.

obviamente para poder insertar el registro debemos tener una locacion ya insertada a la que vamos a hacer referencia con la llave foranea de la persona, o simplemente la declaramos null usando None. importamos mysql_service.py donde queramos hacer las consultas y ya podremos llamar sus metodos:

from app.mysql_service import get_personas, get_persona, intert_persona, delete_persona
    intert_persona(1,'sebastian','hernandez', None)
    delete_persona(1)
    persona = get_persona(2)
    personas = get_personas()

Recuerden que el repositorio está en github github hechenle un ojo a la documentacion doc

Escribe tu comentario
+ 2
Ordenar por:
2
5371Puntos

Hola, soy nuevo en flask y he estado probando SQLAlchemy como ORM, pero he tenido problemas al querere manejar un modelo por archivo, por ejemplo locaciones.py y personas.py, al momento de hacer el db.create_all(), sólo me crea una tabla. Sabes a que se puede deber o si es una limitación de la librería.

Saludos.

1
3936Puntos
un año

No sabria decirte muy bien, la verdad yo no use el db.create_all() yo cree las tablas de la base de datos manualmente con sql.

1
2 meses

En mi caso, entre en MySQL y cree la base de datos manualmente, pero las tablas se crearon solas de la siguiente manera:
En el archivo config.py agregue la siguiente linea:
SQLALCHEMY_TRACK_MODIFICATIONS = False

1
12099Puntos

No entendía para que importaba flask-marshmallow, después me di cuenta que no lo terminaste implementando. 😕 xd

1

Hola! por casualidad hiciste la app de tareas con sql? gracias

1
14555Puntos

Una pregunta soy nuevo en el uso de la conexión de la base de datos, mi duda es, ¿qué se supone que va en la SECRET_KEY?

2
12099Puntos
10 meses

Encontré esto en un foro:
link: https://qastack.mx/programming/7382149/purpose-of-django-setting-secret-key

La documentación de Django para la firma criptográfica cubre los usos de la configuración ‘SECRET_KEY’:

Este valor [la SECRET_KEYconfiguración] es la clave para asegurar los datos firmados: es vital que mantenga esto seguro, o los atacantes podrían usarlo para generar sus propios valores firmados.

(También se hace referencia a esta sección de la documentación de Django para la configuración ‘SECRET_KEY’ ).

La API de firma criptográfica en Django está disponible para cualquier aplicación para firmas de valores criptográficamente seguras. Django hace uso de esto en varias características de nivel superior:

Firma de datos serializados (por ejemplo, documentos JSON).

Tokens únicos para una sesión de usuario, solicitud de restablecimiento de contraseña, mensajes, etc.

Prevención de ataques entre sitios o de repetición agregando (y luego esperando) valores únicos para la solicitud.

Generando una sal única para funciones hash.

Entonces, la respuesta general es: hay muchas cosas en una aplicación de Django que requieren una firma criptográfica, y la configuración ‘SECRET_KEY’ es la clave utilizada para esas. Debe tener una cantidad de entropía criptográficamente fuerte (difícil de adivinar para las computadoras) y única entre todas las instancias de Django.

1
14555Puntos
10 meses

Gracias, ya iba a poner o algo al respecto, por ejemplo me encontré con lo siguiente link
donde dice que es una llave random, y para eso este otro link para generarla.