Capítulo 5. Modelo lingüístico y Bases de Datos en AWS

En esta sección desarrollamos el modelo lingüístico con distintos algoritmos para introducir frases en la base de datos, para seleccionar frases, y para corregir frases.

Posteriormente, aprendemos cómo crear una base de datos y tablas en Amazon Web Services. Aprendemos cómo conectarnos a la base de datos mediante pgAdmin. Usando pgAdmin, también escribimos algunas consultas para acceder a la información relevante en nuestra base de datos.


YouTube (sección 1a)
YouTube (sección 1b)
YouTube (sección 1c)
YouTube (sección 1d)
YouTube (sección 3)
YouTube (Sección 4)
GitHub
Modelo lingüístico

En esta sección desarrollamos el modelo lingüístico, aprendemos a añadir frases a nuestra base de datos, aprendemos a seleccionar frases de esa base de datos y el usuario tiene que introducir la frase correcta. Finalmente, desarrollamos una algoritmo en el que corregimos la frase introducida por el usuario y le damos información sobre si la frase es correcta o incorrecta.

Introducción a Postgres

En esta sección, estudiamos qué es Postgres y qué es SQL.

Crear una base de datos Postgres en AWS

En esta sección, aprendemos a crear una base de datos conectada a AWS. Introducimos algunos cambios en nuestro código para crear la base de datos, también modificamos algún código en GitHub para proteger información sensible, e introducimos cambios en el conjunto de datos de AWS para permitir el acceso a la base de datos desde pgAdmin.

Consultas para extraer información de nuestra base de datos

En esta sección, aprendemos consultas básicas en Postgres para acceder a la información relevante en nuestra base de datos.

Reto Semanal

Esta semana nos centramos en el modelo lingüístico, y en la creación de la base de datos en AWS. Sigue los pasos del capítulo para desarrollar tu propio modelo lingüístico y tu propia base de datos.

Modelo lingüístico

Algunos enlaces útiles

Los enlaces al video de YouTube y la cuenta de GitHub para esta sección están a continuación:

YouTube (sección 1a) YouTube (sección 1b) YouTube (sección 1c) YouTube (sección 1d) GitHub

En esta sección consta de tres partes en la que desarrollamos el modelo lingüístico. Primero, aprendemos a añadir frases a nuestra base de datos. Segundo, aprendemos a seleccionar frases de esa base de datos y el usuario tiene que introducir la frase correcta. Tercero, desarrollamos una algoritmo en el que corregimos la frase introducida por el usuario y le damos información sobre si la frase es correcta o incorrecta.

Añadir frases a nuestra base de datos

Para añadir frases a nuestra base de datos, tenemos que conectar un formulario (panel de abajo a la izquierda) con nuestra ruta (panel de abajo a la derecha). El proceso es muy parecido al estudiado en los capítulos anteriores. Por lo tanto, solo presento el código. Una explicación más completa está en el primer video de esta sección.

Formulario para añadir frases

    from flask_wtf import FlaskForm
    from wtforms import StringField, PasswordField, SubmitField
    from wtforms.validators import DataRequired, Length, Email, EqualTo   
    
    class AddForm(FlaskForm):
  incorrect_sentence = StringField('Frase Incorrecta', 
  [InputRequired()])
  correct_sentence_one = StringField('Frase Correcta 1', 
  [InputRequired()], default="none")
  correct_sentence_two = StringField('Frase Correcta 2', 
  [InputRequired()], default="none")
  correct_sentence_three = StringField('Frase Correcta 3', 
  [InputRequired()], default="none")
  objective = SelectField('Objetivo', [InputRequired()], 
    choices=[('Genero', 'Genero'), ('Número', 'Número')])
  source = SelectField('Fuente', [InputRequired()], 
    choices=[('Inteligencia Artificial', 'Inteligencia Artificial'), 
    ('Persona', 'Persona'), ('Lingüista', 'Lingüista')])
  submit = SubmitField('Añadir')
Añadir frases a nuestra base de datos

    #Add a new sentence
    @light_talk_app.route('/light_talk_app/añadir_frase', 
    methods=['GET','POST'])
    @login_required
    def add_sentence():
        form = AddForm()
        if form.validate_on_submit():
            incorrect_sentence = form.incorrect_sentence.data
            correct_sentence_one = form.correct_sentence_one.data
            correct_sentence_two = form.correct_sentence_two.data
            correct_sentence_three = form.correct_sentence_three.data
            your_sentence = "none"
            objective = form.objective.data
            source = form.source.data
            result_string = "none"
            result_num= "nan"
            group = 'general'
            university = 'University of Salamanca'
            year = 2024
        
            sentence = Sentence(incorrect_sentence=incorrect_sentence, 
            correct_sentence_one=correct_sentence_one, 
            correct_sentence_two=correct_sentence_two, 
            correct_sentence_three=correct_sentence_three, 
            correct_sentence_four="none", your_sentence=your_sentence, 
            objective=objective, source=source, 
            result_string=result_string, result_num=result_num,  
            group=group, university=university, year=year, 
            author=current_user)
            db.session.add(sentence)
            db.session.commit()
            return redirect(url_for('light_talk_app.light_talk_app_home'))
        return render_template('light_talk_app/add_sentence.html', 
        title='add sentence', form=form)

Seleccionar y verificar frases de nuestra base de datos

El proceso para seleccionar y verificar frases de nuestra base de datos es muy parecido al proceso de añadir frases, pero los algoritmos en las rutas son diferentes. El proceso está explicado con detalle en los videos 1b y 1c. Además, explicaré el código durante las clases.

Introducción a Postgres

En esta sección, estudiamos qué es Postgres y qué es SQL.

¿Qué es Postgres?

¿Qué es PostgreSQL?

PostgreSQL es un sistema de base de datos relacional avanzado, de clase empresarial y de código abierto. PostgreSQL soporta consultas tanto SQL (relacionales) como JSON (no relacionales).

PostgreSQL es una base de datos altamente estable respaldada por más de 20 años de desarrollo por parte de la comunidad de código abierto.

PostgreSQL se utiliza como base de datos principal para muchas aplicaciones web, así como para aplicaciones móviles y de análisis.

¿Por qué usar PostgreSQL?

PostgreSQL viene con muchas características destinadas a ayudar a los desarrolladores a construir aplicaciones, a los administradores a proteger la integridad de los datos y a construir entornos tolerantes a fallos, y a ayudarle a gestionar sus datos sin importar el tamaño del conjunto de datos. Además de ser gratuito y de código abierto, PostgreSQL es altamente extensible. Por ejemplo, puedes definir tus propios tipos de datos, construir funciones personalizadas, e incluso escribir código en diferentes lenguajes de programación sin recompilar tu base de datos.

Instalación de lenguajes procedurales

PostgreSQL permite que las funciones definidas por el usuario se escriban en otros lenguajes además de SQL y C. Estos otros lenguajes se denominan genéricamente lenguajes procedurales (PLs). Para una función escrita en un lenguaje procedural, el servidor de la base de datos no tiene conocimiento incorporado sobre cómo interpretar el texto fuente de la función. En su lugar, la tarea se pasa a un manejador especial que conoce los detalles del lenguaje. El manejador podría hacer todo el trabajo de análisis, sintaxis, ejecución, etc. por sí mismo, o podría servir como "pegamento" entre PostgreSQL y una implementación existente de un lenguaje de programación. El propio manejador es una función en lenguaje C compilada en un objeto compartido y cargada bajo demanda, al igual que cualquier otra función en C.

Actualmente hay cuatro lenguajes procedurales disponibles en la distribución estándar de PostgreSQL: PL/pgSQL, PL/Tcl, PL/Perl y PL/Python.

Lenguajes procedurales
¿Qué es SQL?

El lenguaje de consulta estructurada (SQL) es un lenguaje de programación para almacenar y procesar información en una base de datos relacional. Una base de datos relacional almacena información en forma de tabla, con filas y columnas que representan diferentes atributos de datos y las diversas relaciones entre los valores de los datos. Puedes utilizar sentencias SQL para almacenar, actualizar, eliminar, buscar y recuperar información de la base de datos. También puedes usar SQL para mantener y optimizar el rendimiento de la base de datos.

Más información sobre SQL en el siguiente enlace:

SQL-AWS

Creando una base de datos Postgres en AWS vinculada a nuestro proyecto

Hasta ahora, hemos utilizado una base de datos sqlite para desarrollar nuestra aplicación. Ahora, es momento de desplegar nuestra aplicación en AWS mientras conectamos nuestros datos a una base de datos Postgres, es decir, debemos crear una base de datos de producción. Los enlaces al video de YouTube y a la cuenta de GitHub para esta sección están a continuación:

YouTube (sección 3) GitHub

Procedimiento para conectar nuestros datos a una base de datos Postgres

El procedimiento para conectar nuestros datos a una base de datos Postgres consta de tres pasos:

  1. En Amazon Web Service. En el entorno donde hemos alojado nuestra aplicación, debemos ir a la configuración y, en la base de datos, debemos crear una base de datos y modificar las reglas de entrada para permitir el acceso a la base de datos. Siga las instrucciones en el video.

  2. En nuestra computadora local. Una vez que hemos creado una base de datos en AWS, debemos crear todas las bases de datos y las tablas. Debemos hacerlo desde nuestra computadora local siguiendo los siguientes pasos:

    1. En el archivo __init__.py, debemos escribir el siguiente código: 
      
    DBVAR = 'postgresql://username:password@endpoint:5432/ebdb'
    application.config['SQLALCHEMY_DATABASE_URI'] = DBVAR 
    application.config['SQLALCHEMY_BINDS'] = {'light_talk': DBVAR}
      Donde en DBVAR, debes introducir los siguientes cinco bloques de información:

      • Nombre de usuario: Este es el nombre de usuario que elegiste al crear la base de datos. Te sugiero elegir el nombre de usuario postgres, ya que cuando programamos la base de datos utilizando la línea de comandos y pgAdmin, ese es el nombre estándar. Sin embargo, elige el nombre que decidas, pero asegúrate de recordarlo.

      • Contraseña: Esta es la contraseña que eliges al crear la base de datos. Recuerda esa contraseña, ya que la necesitaremos más adelante para conectarnos a la base de datos.

      • Endpoint: Este es el endpoint de la base de datos que obtienes desde la página de RDS en AWS.

      • Puerto: El puerto para bases de datos Postgres es 5432.

      • Nombre de la base de datos: El nombre de la base de datos cuando se crea una base de datos dentro de Elastic Beanstalk es ebdb por ElasticBeanstalkDataBase.

    2. En la terminal, debemos escribir: python. Una vez que estamos en la terminal de python, debemos escribir: from capp import db, y luego: db.create_all().

  3. En GitHub. Al igual que con el SECRET_KEY, queremos proteger la información sensible en nuestra cuenta de GitHub, ya que no queremos divulgar nuestro nombre de usuario, contraseña y el endpoint de nuestra base de datos. Para proteger esa información, necesitamos introducir las siguientes líneas de código y colocarlas en GitHub: 
    
    DBVAR = f"postgresql://{os.environ['RDS_USERNAME']}:{os.environ['RDS_PASSWORD']}
    @{os.environ['RDS_HOSTNAME']}/{os.environ['RDS_DB_NAME']}"
  4. En AWS, dirígete a CodePipeline y libera los cambios. Una vez que hayamos liberado los cambios, deberíamos verificar que nuestra aplicación funcione correctamente al poblar la base de datos (registrar un nuevo usuario y agregar algunas frases en la Light Talk App). También debemos verificar que la funcionalidad de inicio de sesión funcione correctamente.

Conexión y consultas a nuestra base de datos Postgres

Conexión a nuestra base de datos Postgres utilizando pgAdmin

Una vez que hemos creado nuestras bases de datos con tablas, es momento de acceder a esas bases de datos y realizar algunas consultas para utilizar la información en ellas. Usamos pgAdmin para acceder a nuestras bases de datos. Procedemos en tres pasos diferentes.

YouTube (Sección 4) GitHub
  1. Descargar pgAdmin para Mac o Windows:
    pgAdmin

  2. En AWS, debemos permitir que nuestra base de datos sea accesible desde diferentes IPs (universidad, casa, etc.). Para hacerlo, debes seguir los siguientes pasos (sigue las instrucciones del video).

    1. En AWS RDS, accede a tu base de datos.

    2. Selecciona los grupos de seguridad VPC.

    3. Selecciona las reglas de entrada.

    4. Edita las reglas de entrada creando una nueva regla de entrada, donde permites todo el tráfico desde tu IP actual.

  3. En pgAdmin, debemos conectarnos a la base de datos alojada en el servidor de AWS siguiendo los siguientes pasos:

    1. Crea una nueva conexión de servidor, y nómbrala como prefieras.

    2. En la conexión, introduce el EndPoint de tu base de datos de Amazon RDS.

    3. En la conexión, también debes introducir el usuario y la contraseña que creaste en AWS.

Consultas en nuestra base de datos usando pgAdmin

Todas las consultas en esta sección son una adaptación a nuestras bases de datos de las consultas en el siguiente video:

FreeCodeCamp

Vamos a introducir algunas consultas útiles.

Comando SELECT:

    SELECT * FROM public.user_table;
    SELECT username, email FROM public.user_table;
    SELECT password FROM public.user_table;
Comando ORDER BY:

    SELECT * FROM public.user_table ORDER BY username;
    SELECT * FROM public.user_table ORDER BY username ASC;
    SELECT * FROM public.user_table ORDER BY username DESC;
Timestamps y Fechas:

    SELECT NOW();
    SELECT NOW()::DATE;
    SELECT NOW()::TIME;
Tipos de fecha/hora
Sumando y Restando Fechas:

    SELECT NOW() - INTERVAL '1 YEAR';
    SELECT NOW()::DATE - INTERVAL '1 YEAR';
    SELECT NOW()::DATE - INTERVAL '5 DAYS';
    SELECT (NOW() + INTERVAL '5 DAYS')::DATE;
Extrayendo Campos:

    SELECT EXTRACT(YEAR FROM NOW());
    SELECT EXTRACT(MONTH FROM NOW());
    SELECT EXTRACT(DAY FROM NOW());
    SELECT EXTRACT(DOW FROM NOW());
    SELECT EXTRACT(CENTURY FROM NOW());
Eliminar registros:

    DELETE FROM  public.user_table WHERE id=1;
Actualizar registros:

    UPDATE public.user_table  SET email='hello@demo.com' 
    WHERE id=1;
    SELECT * FROM public.user_table  WHERE id=1;
    UPDATE public.user_table  SET email='hello1@demo.com',
    username='name1' WHERE id=1;
    SELECT * FROM person WHERE id=1;
EN CONFLICTO, NO HACER NADA:

    INSERT INTO public.user_table 
    (id, username, email, password)
    VALUES (1, 'name2', 'email2@demo.com', 'regn')
    ON CONFLICT (id) DO NOTHING;
    SELECT * FROM public.user_table;
UPSERT:

    SELECT * FROM public.user_table  WHERE id=1;
    INSERT INTO public.user_table 
    (id, username, email, password) 
    VALUES (1, 'name2', 'email4@demo.com', 'regn')
    ON CONFLICT (id) DO UPDATE SET email=EXCLUDED.email;

Reto Semanal

Esta semana nos centramos en el modelo lingüístico, y en la creación de la base de datos en AWS. Sigue los pasos del capítulo para desarrollar tu propio modelo lingüístico y tu propia base de datos.

Chat Principal