WhatsApp

  
Practica de Base de Datos con SQLAlchemy

Introducción a SQLAlchemy en Python 3

Hola a todos. Como parte de nuestros esfuerzos continuos para simplificar el desarrollo con bases de datos en Python, hoy nos centraremos en SQLAlchemy, un ORM (Object Relational Mapper) muy popular y completo. SQLAlchemy proporciona una forma sencilla de interactuar con las bases de datos haciendo uso del lenguaje que ya conocemos, Python. Vamos a realizar algunos ejercicios prácticos para conocer mejor sus funcionalidades.

Instalación

Comencemos con la instalación, solo necesitamos ejecutar el siguiente comando en nuestro entorno Python:
pip install sqlalchemy

Primeros ejercicios SQLAlchemy

Conexion con la base de datos

                
                from sqlalchemy import create_engine
                # En este caso estamos conectandonos a una base de datos SQLite
                engine = create_engine('sqlite:///example.db', echo = True)
                
            

Creacion de Tablas

                
                from sqlalchemy import Column, Integer, String, MetaData
                from sqlalchemy.ext.declarative import declarative_base
                Base = declarative_base()
                class User(Base):
                    __tablename__ = 'users'
                    id = Column(Integer, primary_key=True)
                    name = Column(String)
                    fullname = Column(String)
                    password = Column(String)
                # Este comando crea todas las tablas necesarias en la base de datos
                Base.metadata.create_all(engine)
                
            

Inserción de datos

                
                from sqlalchemy.orm import sessionmaker
                Session = sessionmaker(bind=engine)
                # creamos una nueva sesion
                session = Session()
                # creamos un nuevo usuario
                user = User(name='ed', fullname='Ed Jones', password='edspassword')
                # añadimos el usuario a la sesión
                session.add(user)
                # Confirmamos la transacción
                session.commit()
                
            

Consulta de datos

                
                # Obtenemos todos los usuarios
                users = session.query(User).all()
                for user in users:
                    print(user.name, user.fullname, user.password)
                
            

Como podemos ver, SQLAlchemy nos permite manejar nuestra base de datos de una forma muy pythonica, sin necesidad de escribir SQL crudo, lo que facilita y agiliza el proceso de desarrollo.

Cómo Manipular Usuarios con SQLAlchemy en Python

¡Bienvenidos nuevamente! En esta entrada, nos adentraremos en dos operaciones comunes en cualquier aplicación de gestión de usuarios: modificar y eliminar usuarios. Como ya sabemos, SQLAlchemy nos proporciona una interfaz de alto nivel para interactuar con nuestras bases de datos SQL. Entonces, ¡adelante!

Modificar un Usuario

Supongamos que necesitamos modificar el nombre de un usuario. Para este ejemplo, buscaremos a un usuario por su nombre y luego actualizaremos su nombre con uno nuevo.

                
                from sqlalchemy.orm import sessionmaker
                # creamos una nueva sesion
                Session = sessionmaker(bind=engine)
                session = Session()
                # buscamos al usuario con el nombre actual
                user = session.query(User).filter_by(name='old_name').first()
                if user is not None:
                    # cambio del nombre del usuario
                    user.name = 'new_name'
                    # Confirmamos la transacción
                    session.commit()
                
            

Eliminar un Usuario

Ahora, cubramos el caso de eliminar un usuario de nuestra base de datos. En este ejemplo, buscamos un usuario por su ID y si existe, lo eliminamos.

                
                from sqlalchemy.orm import sessionmaker
                # creamos una nueva sesion
                Session = sessionmaker(bind=engine)
                session = Session()
                # buscamos al usuario por su id
                user = session.query(User).get(user_id)
                if user is not None:
                    # eliminamos al usuario
                    session.delete(user)
                    # Confirmamos la transacción
                    session.commit()                
                
            

En Resumen

En este blog, hemos cubierto dos aspectos muy comunes y necesarios para cualquier operación de gestión de usuarios: modificar y eliminar usuarios. Al igual que la inserción y el retorno de datos, SQLAlchemy nos proporciona una forma muy simple de realizar estas tareas. Como siempre, es genial tener esta flexibilidad en Python y SQLAlchemy ciertamente nos facilita la vida a la hora de interactuar con nuestras bases de datos.

Conclusión

SQLAlchemy es una herramienta potente que puede traer grandes beneficios a tu proyecto, todo depende del uso que le des. Este blog solo rasca la superficie de lo que puedes hacer con SQLAlchemy, te invito a que explores más por tu cuenta, te sorprenderá su capacidad.

Hasta la próxima.


Relacionar Tablas: Usuarios y sus Dispositivos Móviles

En una base de datos relacional a menudo necesitamos vincular la información de dos o más tablas. Un caso común puede ser tener una tabla para los usuarios y otra para los dispositivos móviles que utilizan. Con SQLAlchemy, el mapeo y la gestión de estas relaciones es muy sencillo.

Crear las Tablas y las Relaciones

                
                from sqlalchemy import Column, Integer, String, ForeignKey
                from sqlalchemy.orm import relationship
                class User(Base):
                   __tablename__ = 'users'
                   id = Column(Integer, primary_key=True)
                   name = Column(String)
                   devices = relationship("Device", back_populates="user")
                class Device(Base):
                   __tablename__ = 'devices'
                   id = Column(Integer, primary_key=True)
                   name = Column(String)
                   user_id = Column(Integer, ForeignKey('users.id'))
                   user = relationship("User", back_populates="devices")
                
            

Gracias a la función relationship(), SQLAlchemy puede manejar las relaciones bidireccionales entre las clases User y Device. Además, con el parámetro ForeignKey(), SQLAlchemy sabe cómo enlazar las dos tablas en la base de datos. Ahora, un usuario puede tener varios dispositivos y a cada dispositivo se le puede acceder a través de su propiedad 'user'.

Agregar un Dispositivo a un Usuario

                
                    # crear un nuevo usuario
                    user = User(name='John Doe')
                    # crear un nuevo dispositivo
                    device = Device(name='John's iPhone')
                    # Agregar dispositivo al usuario
                    user.devices.append(device)
                    # Guardar los cambios
                    session.add(user)
                    session.commit()
                
            

Usamos el método append del objeto relationship ('devices') para agregar un nuevo dispositivo a la lista de dispositivos de un usuario.

Relacionar un Usuario a un Dispositivo

                
                    # crear un nuevo usuario
                    user = User(name='Jane Doe')
                    # crear un nuevo dispositivo
                    device = Device(name='Jane's iPad')
                    # Relacionar usuario al dispositivo
                    device.user = user
                    # Guardar los cambios
                    session.add(device)
                    session.commit()
                
            

Asimismo, podemos poner un usuario en la propiedad 'user' del objeto dispositivo para asignar dicho usuario a ese dispositivo.

Conclusión

SQLAlchemy nos permite manipular las relaciones entre varias tablas de manera sencilla y eficiente. Como éste, la mayoría de los sistemas de gestión de bases de datos trabajan con relaciones entre tablas, y de hecho, es uno de sus puntos fuertes sobre otros tipos de bases de datos (no relacionales). Por tanto, saber cómo funcionan estas relaciones y cómo manejarlas en Python con SQLAlchemy es una habilidad esencial para cualquier desarrollador de bases de datos.

Cosulta el siguiente Codigo



en IA
Practica de Base de Datos  con SQLAlchemy
ASIMOV Ingeniería S. de R.L. de C.V., Emiliano Nava 27 octubre, 2023
Compartir
Categorías


Iniciar sesión dejar un comentario

  
Programación Orientada a Objetos