From 7b1f5b8b78d4da6de7918c3bee06d62243717466 Mon Sep 17 00:00:00 2001 From: fenix Date: Fri, 20 Feb 2026 12:38:19 +0100 Subject: [PATCH] despegamos... desde el Valdelab36.art , 3,2,1... --- TAREAS.org | 83 ++++++++++++++++++++++++++ acceso-a-MongoDB-via-java.jar | 77 ++++++++++++++++++++++++ acceso-a-sqlite-via-java.jar | 98 +++++++++++++++++++++++++++++++ crud_mongodb.py | 103 +++++++++++++++++++++++++++++++++ crud_sqlite.py | 91 +++++++++++++++++++++++++++++ dam.db | Bin 0 -> 16384 bytes 6 files changed, 452 insertions(+) create mode 100644 TAREAS.org create mode 100644 acceso-a-MongoDB-via-java.jar create mode 100644 acceso-a-sqlite-via-java.jar create mode 100644 crud_mongodb.py create mode 100644 crud_sqlite.py create mode 100644 dam.db diff --git a/TAREAS.org b/TAREAS.org new file mode 100644 index 0000000..b2d0bc6 --- /dev/null +++ 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 diff --git a/acceso-a-MongoDB-via-java.jar b/acceso-a-MongoDB-via-java.jar new file mode 100644 index 0000000..e2702e8 --- /dev/null +++ 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 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(); + } + } + } +} \ No newline at end of file diff --git a/acceso-a-sqlite-via-java.jar b/acceso-a-sqlite-via-java.jar new file mode 100644 index 0000000..cb073a7 --- /dev/null +++ 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(); + } + } +} + diff --git a/crud_mongodb.py b/crud_mongodb.py new file mode 100644 index 0000000..8fbe14b --- /dev/null +++ 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() diff --git a/crud_sqlite.py b/crud_sqlite.py new file mode 100644 index 0000000..612a502 --- /dev/null +++ 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() diff --git a/dam.db b/dam.db new file mode 100644 index 0000000000000000000000000000000000000000..778022d80543b4ea32242edc7a6e957c402de653 GIT binary patch literal 16384 zcmeI&&uSAv90%~3-Nd5OuBF<5u`oGE6H>i+78=7OL^qpsy9IM9)9$nclHF$iTml}f zPtue0kdrS^SbT?G#iJlTg439|*&?1qseFGhJG(o-`R(i{ry;w$WA-D-j{IOKBKC~j zBb1VD#t0$0YB|;Bp{bL_YdRnJO|O%uU?9aH9(sN_>vDCQ*Bs8A+6$Aj*-ciy!xp0NvX7ciFsz3{^_y=PD~*?N*^$rM;<1I2x#}?|vvp zvGfk*wM#u?bZxNgiJ{z5Gb?YO)1^YGL{Is&X8PdtOv_YC@BamG5%!Ng5ygSX{w%4; zbZ>6FC&nk^qv{Y4fB*y_009U<00Izz00bZa0SNp%fk%3dJlS~Zhsim!eK$xZ$FUsm z#K~mXKNJtO9H|yfakbBHiy%rSo*XxlNvOs)XpU???n*cCSyKdu$wah8B!|gaq(;N5 z{l8{>CdM~)KtKQj5P$##AOHafKmY;|fB*y_a8m{DYI>2*KJw64s9vJ!HwgNV|Nk$D z@x{0_E^g{8V%-pc00bZa0SG_<0uX=z1Rwx`|65>P&yy;pX50^1Lk3=Q=DBkGKws7J iq(o`W6U