despegamos... desde el Valdelab36.art , 3,2,1...

2026-02-20 12:38:19 +01:00 · 2026-02-20 12:38:19 +01:00 · 7b1f5b8b78
parent a7a8bdc6b3
commit 7b1f5b8b78
6 changed files with 452 additions and 0 deletions
--- a/TAREAS.org
+++ b/TAREAS.org
@ -0,0 +1,83 @@
+#+TITLE: Notas del Proyecto CRUD Python
+#+DATE: 2026-02-20
+
+* Estado del Proyecto
+
+- [X] Traducidos los ficheros Java a Python (SQLite + MongoDB)
+- [X] =crud_sqlite.py= testeado y funcional ✅
+- [ ] =crud_mongodb.py= escrito pero pendiente de testear (falta servidor MongoDB)
+- [ ] Incorporar librería =Faker= para poblar con datos de prueba
+
+* MongoDB en localhost — Modus Operandi
+
+** El problema
+
+MongoDB *no está en los repositorios oficiales de Debian* (a diferencia de MariaDB/PostgreSQL).
+Instalarlo nativo implica:
+1. Añadir el repo de MongoDB Inc. manualmente
+2. Importar claves GPG
+3. Lidiar con incompatibilidades de versión (libssl, etc.)
+4. El servicio =mongod= queda instalado permanentemente
+
+** La solución más simple: Docker 🐳
+
+Ya tenemos Docker instalado en el sistema (=Docker 29.2.1=).
+
+#+begin_example
+┌─────────────────────────────────────────────┐
+│  Debian (localhost)                         │
+│                                             │
+│   crud_mongodb.py ──► localhost:27017       │
+│                            │                │
+│              ┌─────────────┴──────────────┐ │
+│              │  Contenedor Docker         │ │
+│              │  ┌───────────────────────┐ │ │
+│              │  │  mongod  (servidor)   │ │ │
+│              │  │  puerto 27017        │ │ │
+│              │  │  datos en /data/db    │ │ │
+│              │  └───────────────────────┘ │ │
+│              └────────────────────────────┘ │
+└─────────────────────────────────────────────┘
+#+end_example
+
+** Comandos para arrancar MongoDB con Docker
+
+#+begin_src bash
+# 1. Arrancar MongoDB (descarga la imagen la primera vez ~800MB)
+docker run -d --name mongo-test -p 27017:27017 mongo
+
+# 2. Ejecutar el script Python con:
+#    CADENA_CONEXION = "mongodb://localhost:27017"
+python3 crud_mongodb.py
+
+# 3. Cuando termines, parar y borrar:
+docker stop mongo-test && docker rm mongo-test
+#+end_src
+
+** Alternativas
+
+| *Método*        | *Dificultad* | *Notas*                                     |
+|-----------------+--------------+---------------------------------------------|
+| Docker 🐳      | ⭐ Fácil     | ✅ Ya disponible. Un comando y listo        |
+| Paquete =.deb=  | ⭐⭐ Media   | Repo externo, posibles conflictos libssl    |
+| Atlas (nube)    | ⭐ Fácil     | Requiere cuenta en mongodb.com/atlas (M0 gratuito) |
+
+** Cambio necesario en =crud_mongodb.py=
+
+La cadena de conexión del Java original ya no existe:
+: clusterdam2025.9q7lm.mongodb.net → DNS NXDOMAIN ❌
+
+Para testear en local, cambiar la línea =CADENA_CONEXION= a:
+
+#+begin_src python
+CADENA_CONEXION = "mongodb://localhost:27017"
+#+end_src
+
+* Pendiente: Faker
+
+Incorporar la librería [[https://pythonisas.github.io/Pythonisas][Faker]] para generar datos de prueba aleatorios
+en lugar de los datos hardcodeados actuales.
+
+#+begin_src bash
+pip install faker
+#+end_src
--- a/acceso-a-MongoDB-via-java.jar
+++ b/acceso-a-MongoDB-via-java.jar
@ -0,0 +1,77 @@
+import com.mongodb.ConnectionString;
+import com.mongodb.MongoClientSettings;
+import com.mongodb.MongoException;
+import com.mongodb.client.MongoClient;
+import com.mongodb.client.MongoClients;
+import com.mongodb.client.MongoDatabase;
+import com.mongodb.client.MongoCollection;
+import org.bson.Document;
+import java.util.List;
+
+public class MongoDBEjemploConectaryCrud {
+    public static void main(String[] args) {
+        // Cadena de conexión a MongoDB Atlas
+        String cadenaConexion = "mongodb+srv://MACARENA:XnUKVeI5VcNE4LK1@clusterdam2025.9q7lm.mongodb.net/?retryWrites=true&w=majority&appName=ClusterDAM2025";
+
+        // Configuración del cliente MongoDB utilizando la cadena de conexión
+        MongoClientSettings configuracion = MongoClientSettings.builder()
+                .applyConnectionString(new ConnectionString(cadenaConexion))
+                .build();
+
+        try (MongoClient clienteMongo = MongoClients.create(configuracion)) {
+            try {
+                // Enviar un ping para confirmar que la conexión fue exitosa
+                MongoDatabase baseDatos = clienteMongo.getDatabase("admin");
+                baseDatos.runCommand(new Document("ping", 1));
+                System.out.println("¡Ping a tu despliegue exitoso! Te conectaste correctamente a MongoDB.");
+
+                // Preguntar por las bases de datos disponibles antes de hacer cualquier otra acción
+                System.out.println("\nLista de bases de datos disponibles:");
+                clienteMongo.listDatabaseNames().forEach(System.out::println);
+
+                // Aquí ya puedes elegir o especificar una base de datos que quieras usar
+                MongoDatabase baseDatosSeleccionada = clienteMongo.getDatabase("Peliculas"); // Cambia a tu base de datos
+                System.out.println("\nBase de datos seleccionada: " + baseDatosSeleccionada.getName());
+
+                // Mostrar las colecciones dentro de la base de datos seleccionada
+                System.out.println("\nLista de colecciones en la base de datos '" + baseDatosSeleccionada.getName() + "':");
+                baseDatosSeleccionada.listCollectionNames().forEach(System.out::println);
+
+                // Mostrar los documentos dentro de una colección específica
+                MongoCollection<Document> coleccion = baseDatosSeleccionada.getCollection("ColeccionPeliculas"); // Cambia a tu colección
+                System.out.println("\nDocumentos en la colección '" + coleccion.getNamespace().getCollectionName() + "':");
+
+                // Usar el for-each para recorrer los documentos de la colección
+                for (Document doc : coleccion.find()) {
+                    // Mostrar el contenido del documento de forma comprensible
+                    System.out.println("\nContenido del documento:");
+                    for (String clave : doc.keySet()) {
+                        // Comprobar si el valor es un Array o una referencia de otro Document
+                        Object valor = doc.get(clave);
+                        if (valor instanceof Document) {
+                            // Si es un objeto Document, recorrer sus claves
+                            System.out.println(clave + ": ");
+                            Document subDoc = (Document) valor;
+                            for (String subClave : subDoc.keySet()) {
+                                System.out.println("  " + subClave + ": " + subDoc.get(subClave));
+                            }
+                        } else if (valor instanceof List) {
+                            // Si es un Array (List), mostrar sus elementos
+                            System.out.println(clave + ": ");
+                            List<?> lista = (List<?>) valor;
+                            for (Object item : lista) {
+                                System.out.println("  - " + item);
+                            }
+                        } else {
+                            // Si es un valor normal, imprimir directamente
+                            System.out.println(clave + ": " + valor);
+                        }
+                    }
+                }
+
+            } catch (MongoException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+}
--- a/acceso-a-sqlite-via-java.jar
+++ b/acceso-a-sqlite-via-java.jar
@ -0,0 +1,98 @@
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.Statement;
+import java.io.File;
+
+public class Main {
+    public static void main(String[] args) {
+        // Mensaje de bienvenida
+        System.out.printf("Hello and welcome!\n");
+
+        // Crear la base de datos DAM, tablas, insertar registros y realizar consulta
+        String dbName = "dam.db";
+        String url = "jdbc:sqlite:" + dbName; // Ruta de la base de datos
+
+        try (Connection conn = DriverManager.getConnection(url)) {
+            if (conn != null) {
+                System.out.println("Conexión establecida con la base de datos DAM");
+
+                // Mostrar la ruta completa de la base de datos
+                File dbFile = new File(dbName);
+                System.out.println("Ruta de la base de datos: " + dbFile.getAbsolutePath());
+
+                // Crear las tablas si no existen
+                String createProfesoresTable = "CREATE TABLE IF NOT EXISTS profesores ("
+                        + "id INTEGER PRIMARY KEY AUTOINCREMENT, "
+                        + "nombre TEXT NOT NULL, "
+                        + "asignatura TEXT NOT NULL);";
+
+                String createAlumnosTable = "CREATE TABLE IF NOT EXISTS alumnos ("
+                        + "id INTEGER PRIMARY KEY AUTOINCREMENT, "
+                        + "nombre TEXT NOT NULL, "
+                        + "edad INTEGER NOT NULL, "
+                        + "id_profesor INTEGER, "
+                        + "FOREIGN KEY (id_profesor) REFERENCES profesores(id));";
+
+                try (Statement stmt = conn.createStatement()) {
+                    stmt.execute(createProfesoresTable);
+                    stmt.execute(createAlumnosTable);
+                    System.out.println("Tablas creadas exitosamente.");
+                }
+
+                // Insertar registros en la tabla profesores
+                String insertProfesorSQL = "INSERT INTO profesores (nombre, asignatura) VALUES (?, ?)";
+                try (PreparedStatement pstmt = conn.prepareStatement(insertProfesorSQL)) {
+                    pstmt.setString(1, "Pedro García");
+                    pstmt.setString(2, "Matemáticas");
+                    pstmt.executeUpdate();
+
+                    pstmt.setString(1, "Laura Martínez");
+                    pstmt.setString(2, "Física");
+                    pstmt.executeUpdate();
+
+                    pstmt.setString(1, "José Rodríguez");
+                    pstmt.setString(2, "Química");
+                    pstmt.executeUpdate();
+                }
+
+                // Insertar registros en la tabla alumnos
+                String insertAlumnoSQL = "INSERT INTO alumnos (nombre, edad, id_profesor) VALUES (?, ?, ?)";
+                try (PreparedStatement pstmt = conn.prepareStatement(insertAlumnoSQL)) {
+                    pstmt.setString(1, "Carlos Pérez");
+                    pstmt.setInt(2, 20);
+                    pstmt.setInt(3, 1); // Asignar el profesor con id 1 (Pedro García)
+                    pstmt.executeUpdate();
+
+                    pstmt.setString(1, "Ana López");
+                    pstmt.setInt(2, 22);
+                    pstmt.setInt(3, 2); // Asignar el profesor con id 2 (Laura Martínez)
+                    pstmt.executeUpdate();
+
+                    pstmt.setString(1, "Luis Fernández");
+                    pstmt.setInt(2, 21);
+                    pstmt.setInt(3, 3); // Asignar el profesor con id 3 (José Rodríguez)
+                    pstmt.executeUpdate();
+                }
+
+                // Realizar consulta para obtener todos los alumnos con sus profesores
+                String query = "SELECT a.nombre AS alumno, p.nombre AS profesor "
+                        + "FROM alumnos a "
+                        + "JOIN profesores p ON a.id_profesor = p.id";
+                try (PreparedStatement pstmt = conn.prepareStatement(query);
+                     ResultSet rs = pstmt.executeQuery()) {
+                    System.out.println("Alumnos y sus profesores:");
+                    while (rs.next()) {
+                        String nombreAlumno = rs.getString("alumno");
+                        String nombreProfesor = rs.getString("profesor");
+                        System.out.println("Alumno: " + nombreAlumno + " | Profesor: " + nombreProfesor);
+                    }
+                }
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}
+
--- a/crud_mongodb.py
+++ b/crud_mongodb.py
@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+"""
+Acceso a MongoDB desde Python (CREATE + READ)
+Equivalente al ejemplo Java: acceso-a-MongoDB-via-java.jar
+
+Requisito: pip install pymongo
+"""
+
+from pymongo import MongoClient
+
+# Cadena de conexión a MongoDB Atlas (misma que en el ejemplo Java)
+CADENA_CONEXION = "mongodb+srv://MACARENA:XnUKVeI5VcNE4LK1@clusterdam2025.9q7lm.mongodb.net/?retryWrites=true&w=majority&appName=ClusterDAM2025"
+DB_NAME = "dam"
+
+
+def conectar():
+    cliente = MongoClient(CADENA_CONEXION)
+    # Ping para confirmar conexión (como en el Java)
+    cliente.admin.command("ping")
+    print("¡Ping exitoso! Conectado correctamente a MongoDB.")
+    return cliente
+
+
+def listar_bases_de_datos(cliente):
+    print("\nBases de datos disponibles:")
+    for nombre in cliente.list_database_names():
+        print(f"  - {nombre}")
+
+
+def crear_colecciones(db):
+    # Limpiar datos anteriores para partir de cero
+    db.profesores.drop()
+    db.alumnos.drop()
+
+    # CREATE - Profesores (mismos datos que en el ejemplo SQLite)
+    profesores = [
+        {"_id": 1, "nombre": "Pedro García",    "asignatura": "Matemáticas"},
+        {"_id": 2, "nombre": "Laura Martínez",  "asignatura": "Física"},
+        {"_id": 3, "nombre": "José Rodríguez",  "asignatura": "Química"},
+    ]
+    db.profesores.insert_many(profesores)
+
+    # CREATE - Alumnos
+    alumnos = [
+        {"nombre": "Carlos Pérez",    "edad": 20, "id_profesor": 1},
+        {"nombre": "Ana López",       "edad": 22, "id_profesor": 2},
+        {"nombre": "Luis Fernández",  "edad": 21, "id_profesor": 3},
+    ]
+    db.alumnos.insert_many(alumnos)
+
+    print(f"\nDatos insertados en '{db.name}'.")
+
+
+def listar_colecciones(db):
+    print(f"\nColecciones en '{db.name}':")
+    for nombre in db.list_collection_names():
+        print(f"  - {nombre}")
+
+
+def consultar(db):
+    # READ - Mostrar documentos (estilo Java: recorrer claves)
+    for coleccion_nombre in ["profesores", "alumnos"]:
+        coleccion = db[coleccion_nombre]
+        print(f"\nDocumentos en '{coleccion_nombre}':")
+        for doc in coleccion.find():
+            for clave, valor in doc.items():
+                print(f"  {clave}: {valor}")
+            print("  ---")
+
+    # READ - Consulta con lookup (equivalente al JOIN de SQLite)
+    pipeline = [
+        {"$lookup": {
+            "from": "profesores",
+            "localField": "id_profesor",
+            "foreignField": "_id",
+            "as": "profesor"
+        }},
+        {"$unwind": "$profesor"}
+    ]
+    print("\nAlumnos y sus profesores:")
+    for doc in db.alumnos.aggregate(pipeline):
+        print(f"  Alumno: {doc['nombre']} | Profesor: {doc['profesor']['nombre']}")
+
+
+def main():
+    print("Hello and welcome!\n")
+
+    cliente = conectar()
+    try:
+        listar_bases_de_datos(cliente)
+
+        db = cliente[DB_NAME]
+
+        crear_colecciones(db)       # CREATE
+        listar_colecciones(db)      # READ estructura
+        consultar(db)               # READ datos
+    finally:
+        cliente.close()
+        print("\nConexión cerrada.")
+
+
+if __name__ == "__main__":
+    main()
--- a/crud_sqlite.py
+++ b/crud_sqlite.py
@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+"""
+Acceso a SQLite desde Python (CREATE + READ)
+Equivalente al ejemplo Java: acceso-a-sqlite-via-java.jar
+"""
+
+import sqlite3
+import os
+
+DB_NAME = "dam.db"
+
+
+def conectar():
+    conn = sqlite3.connect(DB_NAME)
+    print(f"Conexión establecida: {os.path.abspath(DB_NAME)}")
+    return conn
+
+
+def crear_tablas(conn):
+    cursor = conn.cursor()
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS profesores (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            nombre TEXT NOT NULL,
+            asignatura TEXT NOT NULL
+        )
+    """)
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS alumnos (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            nombre TEXT NOT NULL,
+            edad INTEGER NOT NULL,
+            id_profesor INTEGER,
+            FOREIGN KEY (id_profesor) REFERENCES profesores(id)
+        )
+    """)
+    conn.commit()
+    print("Tablas creadas exitosamente.")
+
+
+def insertar_datos(conn):
+    cursor = conn.cursor()
+
+    profesores = [
+        ("Pedro García",    "Matemáticas"),
+        ("Laura Martínez",  "Física"),
+        ("José Rodríguez",  "Química"),
+    ]
+    cursor.executemany("INSERT INTO profesores (nombre, asignatura) VALUES (?, ?)", profesores)
+
+    alumnos = [
+        ("Carlos Pérez",    20, 1),
+        ("Ana López",       22, 2),
+        ("Luis Fernández",  21, 3),
+    ]
+    cursor.executemany("INSERT INTO alumnos (nombre, edad, id_profesor) VALUES (?, ?, ?)", alumnos)
+
+    conn.commit()
+    print("Datos insertados.")
+
+
+def consultar(conn):
+    cursor = conn.cursor()
+    cursor.execute("""
+        SELECT a.nombre AS alumno, p.nombre AS profesor
+        FROM alumnos a
+        JOIN profesores p ON a.id_profesor = p.id
+    """)
+    print("\nAlumnos y sus profesores:")
+    for alumno, profesor in cursor.fetchall():
+        print(f"  Alumno: {alumno} | Profesor: {profesor}")
+
+
+def main():
+    print("Hello and welcome!\n")
+
+    if os.path.exists(DB_NAME):
+        os.remove(DB_NAME)
+
+    conn = conectar()
+    try:
+        crear_tablas(conn)      # CREATE estructura
+        insertar_datos(conn)    # CREATE datos
+        consultar(conn)         # READ
+    finally:
+        conn.close()
+        print("\nConexión cerrada.")
+
+
+if __name__ == "__main__":
+    main()
--- a/dam.db
+++ b/dam.db