Session session = HibernateUtil.getSessionFactory().openSession(); // Ojo aquí, el from es caseinsensitive pero la entidad 'Autor' // SI LO ES tiene que ser como se llame la entidad // Esto es lo más sencillo, seleccionar todo de una entidad List<Autor> autores = session.createQuery("from Autor", Autor.class).list(); System.out.println(autores); // Podemos añadir condiciones con Where autores = session.createQuery("from Autor where idautor=6", Autor.class).list(); System.out.println(autores); // Podemos seleccionar algunas propiedades List<String> nombres = session.createQuery("select nombre from Autor", String.class).list(); System.out.println(nombres); // Podemos usar parámetros Query<Autor> query = session.createQuery("from Autor where idautor=:id", Autor.class); query.setParameter("id",6); autores=query.list(); System.out.println(autores); // Si nos fijamos después de cada query ponemos list() // Esto nos sirve para dos cosas: obtener una lista // Y, sobre todo, ejecutar la query. // Las queries son como los procedimientos preparados // No se lanzan hasta que se lo decimos
Categoría: BD
Ejercicio de trabajar con Hibernate
Por partes.
Crear un género:
Genero g=new Genero(); g.setNombre("SteamPunk"); DAO<Genero> gdao=new DAO<>(Genero.class); gdao.save(g);
Crear un libro:
DAO<Genero> gdao=new DAO<>(Genero.class); Genero g=gdao.get(8); Libro l=new Libro(); l.setTitulo("Luna cruel"); l.setPaginas(750); l.setGenero(g); DAO<Libro> ldao=new DAO<>(Libro.class); ldao.save(l);
Crear un autor
DAO<Libro> ldao=new DAO<>(Libro.class); Libro l=ldao.get(9); DAO<Autor> adao=new DAO<>(Autor.class); Autor a=new Autor(); a.setNombre("Juan Perez"); a.getLibros().add(l); adao.save(a);
Todo junto
// Todo junto DAO<Genero> gdao=new DAO<>(Genero.class); DAO<Libro> ldao=new DAO<>(Libro.class); DAO<Autor> adao=new DAO<>(Autor.class); // Creo el género Genero g=new Genero(); g.setNombre("Realismo sucio"); gdao.save(g); // Creo el libro Libro l=new Libro(); l.setTitulo("Cloacas de Barcelona"); l.setPaginas(750); // Le asigno el género que acao de crear l.setGenero(g); ldao.save(l); // Creo el autor Autor a=new Autor(); a.setNombre("Andreu Martín"); // Le añado el libro que acabo de crear a.getLibros().add(l); adao.save(a);
Autores por género.
Con un método:
package com.trifulcas.Biblioteca; import java.util.ArrayList; import java.util.List; import com.trifulcas.DAO.DAO; import com.trifulcas.models.Autor; import com.trifulcas.models.Genero; import com.trifulcas.models.Libro; public class GetAutores { public static void main(String[] args) { DAO<Genero> gdao=new DAO<>(Genero.class); Genero g=gdao.get(8); System.out.println(getAutores2(g)); System.out.println(g.getAutores()); } public static List<Autor> getAutores(Genero genero){ List<Autor> res=new ArrayList<>(); for(Libro libro:genero.getLibros()) { for(Autor autor:libro.getAutores()) { res.add(autor); } } return res; } public static List<Autor> getAutores2(Genero genero){ List<Autor> res=new ArrayList<>(); for(Libro libro:genero.getLibros()) { res.addAll(libro.getAutores()); } return res; } }
Dentro del POJO (no recomendable pero… ya se sabe 😉 )
package com.trifulcas.models; import java.util.ArrayList; import java.util.List; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.OneToMany; @Entity public class Genero { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) @Column(name = "idgenero") private int idGenero; private String nombre; @OneToMany(mappedBy="genero") List<Libro> libros=new ArrayList(); public Genero() { super(); // TODO Auto-generated constructor stub } public int getIdGenero() { return idGenero; } public void setIdGenero(int idGenero) { this.idGenero = idGenero; } public String getNombre() { return nombre; } public void setNombre(String nombre) { this.nombre = nombre; } public List<Libro> getLibros() { return libros; } public void setLibros(List<Libro> libros) { this.libros = libros; } public List<Autor> getAutores() { List<Autor> res=new ArrayList<>(); for(Libro libro:this.getLibros()) { res.addAll(libro.getAutores()); } return res; } @Override public String toString() { return "Genero [idGenero=" + idGenero + ", nombre=" + nombre + "]"; } }
Seguimos con DAO y más
Añado la clase DAO en un paquete aparte
package com.trifulcas.DAO; import java.util.List; import org.hibernate.Session; import org.hibernate.Transaction; import com.trifulcas.hibernate.HibernateUtil; public class DAO<T> { private Class<T> entityClass; public Session session; public DAO(Class<T> clase) { this.entityClass = clase; session = HibernateUtil.getSessionFactory().openSession(); } public void save(T Objeto) { Transaction transaction = null; try { transaction = session.beginTransaction(); session.persist(Objeto); // commit transaction transaction.commit(); } catch (Exception e) { if (transaction != null) { transaction.rollback(); } e.printStackTrace(); } } public List<T> getAll() { return session.createQuery("from " + entityClass.getSimpleName(), entityClass).list(); } public T get(int id) { return session.get(entityClass, id); } public boolean delete(int id) { Transaction transaction = null; try { transaction = session.beginTransaction(); T objeto = session.get(entityClass, id); session.remove(objeto); transaction.commit(); return true; } catch (Exception ex) { System.out.println(ex.getMessage()); if (transaction != null) { transaction.rollback(); } return false; } } }
Creo la entidad Libro
package com.trifulcas.models; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.JoinColumn; import javax.persistence.ManyToOne; @Entity public class Libro { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) @Column(name = "idlibro") private int idLibro; private String titulo; private int paginas; @ManyToOne @JoinColumn(name="idgenero") private Genero genero; public Libro() { super(); // TODO Auto-generated constructor stub } public int getIdLibro() { return idLibro; } public void setIdLibro(int idLibro) { this.idLibro = idLibro; } public String getTitulo() { return titulo; } public void setTitulo(String titulo) { this.titulo = titulo; } public int getPaginas() { return paginas; } public void setPaginas(int paginas) { this.paginas = paginas; } public Genero getGenero() { return genero; } public void setGenero(Genero genero) { this.genero = genero; } @Override public String toString() { return "Libro [idLibro=" + idLibro + ", titulo=" + titulo + ", paginas=" + paginas + "]"; } }
Añado a Genero la anotación onetomany
package com.trifulcas.models; import java.util.ArrayList; import java.util.List; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.OneToMany; @Entity public class Genero { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) @Column(name = "idgenero") private int idGenero; private String nombre; @OneToMany(mappedBy="genero") List<Libro> libros=new ArrayList(); public Genero() { super(); // TODO Auto-generated constructor stub } public int getIdGenero() { return idGenero; } public void setIdGenero(int idGenero) { this.idGenero = idGenero; } public String getNombre() { return nombre; } public void setNombre(String nombre) { this.nombre = nombre; } public List<Libro> getLibros() { return libros; } public void setLibros(List<Libro> libros) { this.libros = libros; } @Override public String toString() { return "Genero [idGenero=" + idGenero + ", nombre=" + nombre + "]"; } }
Lo anoto en hibernateutil
... configuration.addAnnotatedClass(Libro.class); ...
Y lo pruebo
package com.trifulcas.Biblioteca; import com.trifulcas.DAO.DAO; import com.trifulcas.models.Genero; import com.trifulcas.models.Libro; /** * Hello world! * */ public class App { public static void main( String[] args ) { try { DAO<Genero> gdao=new DAO<>(Genero.class); Genero g=gdao.get(1); System.out.println(g); System.out.println(g.getLibros()); DAO<Libro> ldao=new DAO<>(Libro.class); Libro l=ldao.get(2); System.out.println(l); System.out.println(l.getGenero()); /* * Genero sf=new Genero(); sf.setNombre("Ciencia ficción"); gdao.save(sf); */ //gdao.delete(6); } catch (Exception ex) { System.out.println(ex); } } }
Añado autor, pongo el manytomany y modifico libro para que también lo tenga
package com.trifulcas.models; import java.util.ArrayList; import java.util.List; import javax.persistence.CascadeType; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.JoinColumn; import javax.persistence.JoinTable; import javax.persistence.ManyToMany; import javax.persistence.Table; @Entity @Table(name = "autor") public class Autor { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private int idautor; private String nombre; @ManyToMany(cascade= {CascadeType.MERGE}) @JoinTable(name = "libro_autor", joinColumns = { @JoinColumn(name = "idautor") }, // La de esta entidad inverseJoinColumns = { @JoinColumn(name = "idlibro") }) List<Libro> libros = new ArrayList(); // Constructor por defecto public Autor() { } // Constructor con parámetros public Autor(String nombre) { this.nombre = nombre; } // Getters y Setters public int getIdautor() { return idautor; } public void setIdautor(int idautor) { this.idautor = idautor; } public String getNombre() { return nombre; } public void setNombre(String nombre) { this.nombre = nombre; } public List<Libro> getLibros() { return libros; } public void setLibros(List<Libro> libros) { this.libros = libros; } // Método toString @Override public String toString() { return "Autor{" + "idautor=" + idautor + ", nombre='" + nombre + '\'' + '}'; } }
package com.trifulcas.models; import java.util.ArrayList; import java.util.List; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.JoinColumn; import javax.persistence.ManyToMany; import javax.persistence.ManyToOne; @Entity public class Libro { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) @Column(name = "idlibro") private int idLibro; private String titulo; private int paginas; @ManyToMany(mappedBy="libros") List<Autor> autores=new ArrayList(); @ManyToOne @JoinColumn(name="idgenero") private Genero genero; public Libro() { super(); // TODO Auto-generated constructor stub } public int getIdLibro() { return idLibro; } public void setIdLibro(int idLibro) { this.idLibro = idLibro; } public String getTitulo() { return titulo; } public void setTitulo(String titulo) { this.titulo = titulo; } public int getPaginas() { return paginas; } public void setPaginas(int paginas) { this.paginas = paginas; } public Genero getGenero() { return genero; } public void setGenero(Genero genero) { this.genero = genero; } public List<Autor> getAutores() { return autores; } public void setAutores(List<Autor> autores) { this.autores = autores; } @Override public String toString() { return "Libro [idLibro=" + idLibro + ", titulo=" + titulo + ", paginas=" + paginas + "]"; } }
Lo pruebo:
package com.trifulcas.Biblioteca; import com.trifulcas.DAO.DAO; import com.trifulcas.models.Autor; import com.trifulcas.models.Genero; import com.trifulcas.models.Libro; /** * Hello world! * */ public class App { public static void main(String[] args) { try { DAO<Genero> gdao = new DAO<>(Genero.class); Genero g = gdao.get(1); System.out.println(g); System.out.println(g.getLibros()); DAO<Libro> ldao = new DAO<>(Libro.class); Libro l = ldao.get(2); System.out.println(l); System.out.println(l.getGenero()); DAO<Autor> adao = new DAO<>(Autor.class); Autor a = adao.get(2); System.out.println(a); System.out.println(a.getLibros()); Libro fantasia=ldao.get(7); // Añado el libro al autor a.getLibros().add(fantasia); // Lo guardo adao.save(a); /* * Genero sf = new Genero(); * * sf.setNombre("Fantasía romántica"); * gdao.save(sf); * Libro libro=new Libro(); * libro.setTitulo("Amor en el fin del mundo"); * libro.setPaginas(200); * libro.setGenero(sf); * ldao.save(libro); */ } catch (Exception ex) { System.out.println(ex); } } }
Pasos proyecto
1.- Crear proyecto Maven (maven-archetype-quickstart)
2.- Añadir dependencias: Mysql e hibernate
<dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.32</version> </dependency> <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-core</artifactId> <version>5.6.15.Final</version> </dependency>
3.- Creo la clase HibernateUtil
package com.trifulcas.hibernate; import java.util.Properties; import org.hibernate.SessionFactory; import org.hibernate.boot.registry.StandardServiceRegistryBuilder; import org.hibernate.cfg.Configuration; import org.hibernate.cfg.Environment; import org.hibernate.service.ServiceRegistry; public class HibernateUtil { private static SessionFactory sessionFactory; public static SessionFactory getSessionFactory() { if (sessionFactory == null) { try { Configuration configuration = new Configuration(); // Hibernate settings equivalent to hibernate.cfg.xml's properties Properties settings = new Properties(); settings.put(Environment.DRIVER, "com.mysql.cj.jdbc.Driver"); settings.put(Environment.URL, "jdbc:mysql://localhost:3306/sakila"); settings.put(Environment.USER, "root"); settings.put(Environment.PASS, ""); settings.put(Environment.DIALECT, "org.hibernate.dialect.MySQL5Dialect"); settings.put(Environment.SHOW_SQL, "true"); settings.put(Environment.CURRENT_SESSION_CONTEXT_CLASS, "thread"); configuration.setProperties(settings); ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder() .applySettings(configuration.getProperties()).build(); sessionFactory = configuration.buildSessionFactory(serviceRegistry); } catch (Exception e) { e.printStackTrace(); } } return sessionFactory; } public static void shutdown() { // Close caches and connection pools getSessionFactory().close(); } }
4.- Pongo los datos correctos de conexión: BD, usuario y password (settings.put(Environment.URL, “jdbc:mysql://localhost:3306/biblioteca”);)
5.- Creo mi entidad
package com.trifulcas.models; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.Table; @Entity @Table(name = "genero") public class Genero { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) @Column(name = "idgenero") private int idGenero; private String nombre; public Genero() { super(); // TODO Auto-generated constructor stub } public int getIdGenero() { return idGenero; } public void setIdGenero(int idGenero) { this.idGenero = idGenero; } public String getNombre() { return nombre; } public void setNombre(String nombre) { this.nombre = nombre; } @Override public String toString() { return "Genero [idGenero=" + idGenero + ", nombre=" + nombre + "]"; } }
6.- Lo anotamos en hibernateutil
... configuration.addAnnotatedClass(Genero.class); ...
7.- Lo pruebo:
Session session = HibernateUtil.getSessionFactory().openSession(); try { Genero g = session.get(Genero.class, 1); System.out.println(g); } catch (Exception ex) { System.out.println(ex); } session.close();
Ejercicio Hibernate Biblioteca
Vamos a hacer la siguiente BD y la vamos a implementar con Hibernate
Genero 1–N Libro N–N Autor
Genero: Nombre
Libro: Titulo, paginas
Autor: nombre
CREATE TABLE `biblioteca`.`genero` ( `idgenero` INT NOT NULL AUTO_INCREMENT, `nombre` VARCHAR(45) NULL, PRIMARY KEY (`idgenero`)); CREATE TABLE `biblioteca`.`libro` ( `idlibro` INT NOT NULL AUTO_INCREMENT, `idgenero` INT NULL, `titulo` VARCHAR(45) NULL, `paginas` INT NULL, PRIMARY KEY (`idlibro`)); CREATE TABLE `biblioteca`.`autor` ( `idautor` INT NOT NULL AUTO_INCREMENT, `nombre` VARCHAR(150) NULL, PRIMARY KEY (`idautor`)); CREATE TABLE `libro_autor` ( `idlibro_autor` int(11) NOT NULL AUTO_INCREMENT, `idlibro` int(11) DEFAULT NULL, `idautor` int(11) DEFAULT NULL, PRIMARY KEY (`idlibro_autor`), KEY `fk_libro_idx` (`idlibro`), KEY `fk_autor_idx` (`idautor`), CONSTRAINT `fk_autor` FOREIGN KEY (`idautor`) REFERENCES `autor` (`idautor`) ON DELETE NO ACTION ON UPDATE NO ACTION, CONSTRAINT `fk_libro` FOREIGN KEY (`idlibro`) REFERENCES `libro` (`idlibro`) ON DELETE NO ACTION ON UPDATE NO ACTION ) ALTER TABLE `biblioteca`.`libro` ADD INDEX `fk_genero_idx` (`idgenero` ASC) ; ; ALTER TABLE `biblioteca`.`libro` ADD CONSTRAINT `fk_genero` FOREIGN KEY (`idgenero`) REFERENCES `biblioteca`.`genero` (`idgenero`) ON DELETE NO ACTION ON UPDATE NO ACTION;
Datos de prueba
INSERT INTO `biblioteca`.`genero` (`nombre`) VALUES ('Ficción'), ('No Ficción'), ('Ciencia Ficción'), ('Fantasía'), ('Biografía'); INSERT INTO `biblioteca`.`libro` (`idgenero`, `titulo`, `paginas`) VALUES (1, 'El Gran Gatsby', 180), (2, 'Sapiens: De animales a dioses', 443), (3, 'Dune', 412), (4, 'Harry Potter y la piedra filosofal', 309), (5, 'Steve Jobs', 656); INSERT INTO `biblioteca`.`autor` (`nombre`) VALUES ('F. Scott Fitzgerald'), ('Yuval Noah Harari'), ('Frank Herbert'), ('J.K. Rowling'), ('Walter Isaacson'); INSERT INTO `libro_autor` (`idlibro`, `idautor`) VALUES (1, 1), -- El Gran Gatsby por F. Scott Fitzgerald (2, 2), -- Sapiens: De animales a dioses por Yuval Noah Harari (3, 3), -- Dune por Frank Herbert (4, 4), -- Harry Potter y la piedra filosofal por J.K. Rowling (5, 5); -- Steve Jobs por Walter Isaacson
Ejercicio Colección de funkos
Mi hija quiere hacer una base de datos para guardar su colección de funkos. Los funkos están organizados en colecciones, que tienen un nombre de la colección y el nombre del diseñador. Un funko solo pertenece a una colección. De cada funko queremos guardar el Nombre, Precio, Número,Estilo, Fecha de lanzamiento y Tamaño.
La mayoría de los funkos son de productos audiovisuales (series, películas…). Nos interesa conocer el título de ese producto, la fecha de emisión, la nacionalidad y el número de temporadas.
coleccion
———-
idcoleccion int
nombre varchar(150)
disenyador varchar(150)
funko
—–
idfunko int
idcoleccion int
idaudiovisual int
nombre varchar(150)
precio decimal
numero smallint
estilo varchar(150)
lanzamiento date
tamanyo varchar
audiovisual
———–
idaudiovisual int
titulo varchar(150)
emision date
nacionalidad varchar(150)
temporadas smallint
CREATE TABLE `coleccion` ( `idcoleccion` int(10) unsigned NOT NULL AUTO_INCREMENT, `nombre` varchar(150) DEFAULT NULL, `disenyador` varchar(150) DEFAULT NULL, PRIMARY KEY (`idcoleccion`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci; CREATE TABLE `audiovisual` ( `idaudiovisual` int(10) unsigned NOT NULL AUTO_INCREMENT, `titulo` varchar(150) DEFAULT NULL, `emision` date DEFAULT NULL, `nacionalidad` varchar(150) DEFAULT NULL, `temporadas` smallint(6) DEFAULT NULL, PRIMARY KEY (`idaudiovisual`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci; CREATE TABLE `funko` ( `idfunko` int(10) unsigned NOT NULL AUTO_INCREMENT, `idcoleccion` int(11) unsigned DEFAULT NULL, `idaudiovisual` int(11) unsigned DEFAULT NULL, `nombre` varchar(150) DEFAULT NULL, `precio` decimal(8,2) DEFAULT NULL, `numero` smallint(6) DEFAULT NULL, `estilo` varchar(150) DEFAULT NULL, `lanzamiento` date DEFAULT NULL, `tamanyo` varchar(150) DEFAULT NULL, PRIMARY KEY (`idfunko`), KEY `fk_coleccion_idx` (`idcoleccion`), KEY `fk_audiovisual_idx` (`idaudiovisual`), CONSTRAINT `fk_audiovisual` FOREIGN KEY (`idaudiovisual`) REFERENCES `audiovisual` (`idaudiovisual`) ON UPDATE NO ACTION, CONSTRAINT `fk_coleccion` FOREIGN KEY (`idcoleccion`) REFERENCES `coleccion` (`idcoleccion`) ON UPDATE NO ACTION ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;
Datos de prueba:
INSERT INTO `coleccion` (`nombre`, `disenyador`) VALUES ('Star Wars: Original Trilogy', 'John Doe'), ('Marvel Avengers', 'Jane Smith'), ('Harry Potter', 'Robert Brown'), ('Game of Thrones', 'Emily White'), ('The Walking Dead', 'Michael Green'), ('Disney Classics', 'Sarah Black'), ('DC Comics Superheroes', 'Thomas Blue'), ('Stranger Things', 'Olivia Purple'), ('Rick and Morty', 'Daniel Red'), ('The Simpsons', 'Jessica Pink'), ('Dragon Ball Z', 'Matthew Yellow'), ('Naruto Shippuden', 'Sophia Orange'), ('One Piece', 'James Violet'), ('Pokemon', 'Emma Indigo'), ('Lord of the Rings', 'Christopher Teal'), ('The Office', 'Isabella Grey'), ('Friends', 'Benjamin Azure'), ('My Hero Academia', 'Mia Lime'), ('Overwatch', 'Elijah Olive'), ('Fortnite', 'Charlotte Cyan'); INSERT INTO `audiovisual` (`titulo`, `emision`, `nacionalidad`, `temporadas`) VALUES ('Breaking Bad', '2008-01-20', 'USA', 5), ('Stranger Things', '2016-07-15', 'USA', 4), ('Game of Thrones', '2011-04-17', 'USA', 8), ('Narcos', '2015-08-28', 'USA', 3), ('The Crown', '2016-11-04', 'UK', 4), ('La Casa de Papel', '2017-05-02', 'Spain', 5), ('Dark', '2017-12-01', 'Germany', 3), ('Money Heist', '2017-05-02', 'Spain', 5), ('The Mandalorian', '2019-11-12', 'USA', 2), ('The Witcher', '2019-12-20', 'USA', 2), ('Friends', '1994-09-22', 'USA', 10), ('The Office', '2005-03-24', 'USA', 9), ('Sherlock', '2010-07-25', 'UK', 4), ('Black Mirror', '2011-12-04', 'UK', 5), ('The Simpsons', '1989-12-17', 'USA', 32), ('Rick and Morty', '2013-12-02', 'USA', 5), ('Naruto Shippuden', '2007-02-15', 'Japan', 21), ('One Piece', '1999-10-20', 'Japan', 20), ('Dragon Ball Z', '1989-04-26', 'Japan', 9), ('Attack on Titan', '2013-04-07', 'Japan', 4); INSERT INTO `funko` (`idcoleccion`, `idaudiovisual`, `nombre`, `precio`, `numero`, `estilo`, `lanzamiento`, `tamanyo`) VALUES (1, 3, 'Darth Vader', 12.99, 1, 'Vinyl', '2018-05-04', 'Standard'), (1, 3, 'Luke Skywalker', 12.99, 2, 'Vinyl', '2018-05-04', 'Standard'), (2, 10, 'Iron Man', 14.99, 3, 'Vinyl', '2019-04-26', 'Standard'), (2, 10, 'Captain America', 14.99, 4, 'Vinyl', '2019-04-26', 'Standard'), (3, 7, 'Harry Potter', 11.99, 5, 'Vinyl', '2017-07-31', 'Standard'), (3, 7, 'Hermione Granger', 11.99, 6, 'Vinyl', '2017-07-31', 'Standard'), (4, 2, 'Jon Snow', 13.99, 7, 'Vinyl', '2019-04-14', 'Standard'), (4, 2, 'Daenerys Targaryen', 13.99, 8, 'Vinyl', '2019-04-14', 'Standard'), (5, 1, 'Rick Grimes', 10.99, 9, 'Vinyl', '2018-10-07', 'Standard'), (5, 1, 'Daryl Dixon', 10.99, 10, 'Vinyl', '2018-10-07', 'Standard'), (6, 19, 'Mickey Mouse', 9.99, 11, 'Vinyl', '2019-11-18', 'Standard'), (6, 19, 'Donald Duck', 9.99, 12, 'Vinyl', '2019-11-18', 'Standard'), (7, 11, 'Batman', 12.99, 13, 'Vinyl', '2019-03-01', 'Standard'), (7, 11, 'Superman', 12.99, 14, 'Vinyl', '2019-03-01', 'Standard'), (8, 2, 'Eleven', 14.99, 15, 'Vinyl', '2019-07-04', 'Standard'), (8, 2, 'Jim Hopper', 14.99, 16, 'Vinyl', '2019-07-04', 'Standard'), (9, 17, 'Rick', 13.49, 17, 'Vinyl', '2020-09-20', 'Standard'), (9, 17, 'Morty', 13.49, 18, 'Vinyl', '2020-09-20', 'Standard'), (10, 12, 'Homer Simpson', 11.49, 19, 'Vinyl', '2019-09-29', 'Standard'), (10, 12, 'Bart Simpson', 11.49, 20, 'Vinyl', '2019-09-29', 'Standard'), (11, 14, 'Goku', 12.49, 21, 'Vinyl', '2018-11-18', 'Standard'), (11, 14, 'Vegeta', 12.49, 22, 'Vinyl', '2018-11-18', 'Standard'), (12, 16, 'Naruto Uzumaki', 13.99, 23, 'Vinyl', '2019-02-15', 'Standard'), (12, 16, 'Sasuke Uchiha', 13.99, 24, 'Vinyl', '2019-02-15', 'Standard'), (13, 18, 'Monkey D. Luffy', 14.49, 25, 'Vinyl', '2020-05-20', 'Standard'), (13, 18, 'Roronoa Zoro', 14.49, 26, 'Vinyl', '2020-05-20', 'Standard'), (14, 15, 'Pikachu', 9.99, 27, 'Vinyl', '2019-07-06', 'Standard'), (14, 15, 'Charmander', 9.99, 28, 'Vinyl', '2019-07-06', 'Standard'), (15, 5, 'Frodo Baggins', 11.99, 29, 'Vinyl', '2018-12-19', 'Standard'), (15, 5, 'Gandalf', 11.99, 30, 'Vinyl', '2018-12-19', 'Standard'), (16, 8, 'Michael Scott', 10.99, 31, 'Vinyl', '2019-10-07', 'Standard'), (16, 8, 'Dwight Schrute', 10.99, 32, 'Vinyl', '2019-10-07', 'Standard'), (17, 9, 'Rachel Green', 11.99, 33, 'Vinyl', '2019-05-01', 'Standard'), (17, 9, 'Ross Geller', 11.99, 34, 'Vinyl', '2019-05-01', 'Standard'), (18, 4, 'Izuku Midoriya', 14.99, 35, 'Vinyl', '2020-03-15', 'Standard'), (18, 4, 'Katsuki Bakugo', 14.99, 36, 'Vinyl', '2020-03-15', 'Standard'), (19, 13, 'Tracer', 12.99, 37, 'Vinyl', '2019-10-10', 'Standard'), (19, 13, 'Reaper', 12.99, 38, 'Vinyl', '2019-10-10', 'Standard'), (20, 6, 'Jonesy', 11.49, 39, 'Vinyl', '2019-06-05', 'Standard'), (20, 6, 'Raven', 11.49, 40, 'Vinyl', '2019-06-05', 'Standard'), (1, 3, 'Boba Fett', 14.99, 41, 'Vinyl', '2019-12-05', 'Standard'), (1, 3, 'Princess Leia', 14.99, 42, 'Vinyl', '2019-12-05', 'Standard'), (2, 10, 'Thor', 15.99, 43, 'Vinyl', '2020-02-20', 'Standard'), (2, 10, 'Hulk', 15.99, 44, 'Vinyl', '2020-02-20', 'Standard'), (3, 7, 'Ron Weasley', 11.99, 45, 'Vinyl', '2018-08-31', 'Standard'), (3, 7, 'Albus Dumbledore', 11.99, 46, 'Vinyl', '2018-08-31', 'Standard'), (4, 2, 'Tyrion Lannister', 13.99, 47, 'Vinyl', '2018-03-25', 'Standard'), (4, 2, 'Arya Stark', 13.99, 48, 'Vinyl', '2018-03-25', 'Standard'), (5, 1, 'Michonne', 10.99, 49, 'Vinyl', '2017-04-06', 'Standard'), (5, 1, 'Negan', 10.99, 50, 'Vinyl', '2017-04-06', 'Standard');
Ejemplo modificar datos:
UPDATE `funko` SET `estilo` = 'Metallic' WHERE `idfunko` = 1; UPDATE `funko` SET `estilo` = 'Glow in the Dark' WHERE `idfunko` = 2; UPDATE `funko` SET `estilo` = 'Flocked' WHERE `idfunko` = 3; UPDATE `funko` SET `estilo` = 'Diamond' WHERE `idfunko` = 4; UPDATE `funko` SET `estilo` = 'Chrome' WHERE `idfunko` = 5; UPDATE `funko` SET `estilo` = 'Pearlescent' WHERE `idfunko` = 6; UPDATE `funko` SET `estilo` = 'Translucent' WHERE `idfunko` = 7; UPDATE `funko` SET `estilo` = 'Glitter' WHERE `idfunko` = 8; UPDATE `funko` SET `estilo` = 'Wooden' WHERE `idfunko` = 9; UPDATE `funko` SET `estilo` = '8-Bit' WHERE `idfunko` = 10; UPDATE `funko` SET `estilo` = 'Retro' WHERE `idfunko` = 11; UPDATE `funko` SET `estilo` = 'Vintage' WHERE `idfunko` = 12; UPDATE `funko` SET `estilo` = 'Chibi' WHERE `idfunko` = 13; UPDATE `funko` SET `estilo` = 'Pixel' WHERE `idfunko` = 14; UPDATE `funko` SET `estilo` = 'Steampunk' WHERE `idfunko` = 15; UPDATE `funko` SET `estilo` = 'Graffiti' WHERE `idfunko` = 16; UPDATE `funko` SET `estilo` = 'Art Series' WHERE `idfunko` = 17; UPDATE `funko` SET `estilo` = 'Metallic Gold' WHERE `idfunko` = 18; UPDATE `funko` SET `estilo` = 'Bronze' WHERE `idfunko` = 19; UPDATE `funko` SET `estilo` = 'Silver' WHERE `idfunko` = 20; UPDATE `funko` SET `tamanyo` = 'Large' WHERE `idfunko` = 1; UPDATE `funko` SET `tamanyo` = 'Small' WHERE `idfunko` = 2; UPDATE `funko` SET `tamanyo` = 'Mini' WHERE `idfunko` = 3; UPDATE `funko` SET `tamanyo` = 'Jumbo' WHERE `idfunko` = 4; UPDATE `funko` SET `tamanyo` = 'Super Sized' WHERE `idfunko` = 5; UPDATE `funko` SET `tamanyo` = 'Pocket' WHERE `idfunko` = 6; UPDATE `funko` SET `tamanyo` = 'Mega' WHERE `idfunko` = 7; UPDATE `funko` SET `tamanyo` = 'Giant' WHERE `idfunko` = 8; UPDATE `funko` SET `tamanyo` = 'Titan' WHERE `idfunko` = 9; UPDATE `funko` SET `tamanyo` = 'Colossal' WHERE `idfunko` = 10; UPDATE `funko` SET `tamanyo` = 'Compact' WHERE `idfunko` = 11; UPDATE `funko` SET `tamanyo` = 'Petite' WHERE `idfunko` = 12; UPDATE `funko` SET `tamanyo` = 'Grand' WHERE `idfunko` = 13; UPDATE `funko` SET `tamanyo` = 'Tiny' WHERE `idfunko` = 14; UPDATE `funko` SET `tamanyo` = 'Massive' WHERE `idfunko` = 15; UPDATE `funko` SET `tamanyo` = 'Huge' WHERE `idfunko` = 16; UPDATE `funko` SET `tamanyo` = 'Enormous' WHERE `idfunko` = 17; UPDATE `funko` SET `tamanyo` = 'Oversized' WHERE `idfunko` = 18; UPDATE `funko` SET `tamanyo` = 'Immense' WHERE `idfunko` = 19; UPDATE `funko` SET `tamanyo` = 'Gargantuan' WHERE `idfunko` = 20; UPDATE `funko` SET `estilo` = 'Diamond' WHERE `idfunko` between 20 and 25; UPDATE `funko` SET `estilo` = 'Glitter' WHERE `idfunko` between 25 and 30; UPDATE `funko` SET `estilo` = 'Steampunk' WHERE `idfunko` between 30 and 40; UPDATE `funko` SET `estilo` = 'Metallic' WHERE `idfunko` >40; UPDATE `funko` SET `tamanyo` = 'Small' WHERE `idfunko` between 20 and 25; UPDATE `funko` SET `tamanyo` = 'Compact' WHERE `idfunko` between 25 and 30; UPDATE `funko` SET `tamanyo` = 'Large' WHERE `idfunko` between 30 and 40; UPDATE `funko` SET `tamanyo` = 'Oversized' WHERE `idfunko`>40;
Consultas
-- Consultas con condiciones simples -- audiovisuales con más de 5 temporadas select * from audiovisual where temporadas>5; -- funkos que tengan una 'h' en el nombre select * from funko where nombre like '%h%'; -- colecciones de diseñadores cuyo nombre empiece por 'M' select * from coleccion where disenyador like 'm%'; -- Consultas con joins -- Todos los funkos de la colección 'friends' select funko.* from coleccion join funko on coleccion.idcoleccion=funko.idcoleccion where coleccion.nombre='friends'; -- Todos los funkos del audiovisual 'one piece' select funko.* from audiovisual join funko on audiovisual.idaudiovisual=funko.idaudiovisual where titulo='one piece'; -- Todos los funkos de la colección o el audiovisual 'friends' select f.* from funko f join coleccion c on f.idcoleccion=c.idcoleccion join audiovisual a on f.idaudiovisual=a.idaudiovisual where c.nombre='friends' or a.titulo='friends'; -- Consultas agrupadas -- Total de funkos por colección select coleccion.*, count(idfunko) total from coleccion left join funko using(idcoleccion) group by idcoleccion; -- Total de funkos por audiovisual select audiovisual.*, count(idfunko) total from audiovisual join funko using(idaudiovisual) group by idaudiovisual; -- Total de funkos por estilos ordenados de mayor a menor select estilo,count(idfunko) total from funko group by estilo order by total desc, estilo desc; -- Media de precio de todos los funkos select avg(precio) from funko; -- Total de precios (suma) por tamaño select tamanyo,sum(precio) total from funko group by tamanyo; -- Colecciones con más de 10 funkos (no sé si hay) select coleccion.*, count(idfunko) total from coleccion left join funko using(idcoleccion) group by idcoleccion having total>=4; -- Subconsultas y división -- Coleccion (o colecciones) con mayor número de funkos select coleccion.*, count(idfunko) total from coleccion left join funko using(idcoleccion) group by idcoleccion having total=(maximo); select max(total) total from ( select count(idfunko) total from coleccion left join funko using(idcoleccion) group by idcoleccion) foo; select count(idfunko) total from coleccion left join funko using(idcoleccion) group by idcoleccion order by total desc limit 1 ; -- Junto la primera con alguna de las segundas y voila select coleccion.*, count(idfunko) total from coleccion left join funko using(idcoleccion) group by idcoleccion having total=(select count(idfunko) total from coleccion left join funko using(idcoleccion) group by idcoleccion order by total desc limit 1); -- Lo mismo para audiovisual select audiovisual.*, count(idfunko) total from audiovisual left join funko using(idaudiovisual) group by idaudiovisual having total=(select count(idfunko) total from audiovisual left join funko using(idaudiovisual) group by idaudiovisual order by total desc limit 1); -- Funkos cuyo precio esté por encima de la media -- calculo la media select avg(precio) from funko; select * from funko where precio>(select avg(precio) from funko); -- Consultas con funciones -- Todos los funkos lanzados en febrero select * from funko where month(lanzamiento)=2; -- Total de funkos por año select year(lanzamiento) anyo,count(idfunko) total from funko group by year(lanzamiento); -- Funkos cuyo nombre tenga una longitud mayor de 12 letras select * from funko where length(nombre)>12; -- Funkos lanzados en 2020 o cuyo audiovisual se emitió en 2020 select * from funko join audiovisual on funko.idaudiovisual=audiovisual.idaudiovisual where year(lanzamiento)=2020 or year(emision)=2020;
Consultas agregadas
Aquí tienes algunos ejemplos de consultas de agregación en MongoDB utilizando la colección de libros que has proporcionado:
1. Buscar libros por género y ordenar por fecha de publicación
db.libros.aggregate([
{ $match: { genero: "Novela" } },
{ $sort: { fecha_publicacion: 1 } }
])
2. Contar el número de libros por cada género
db.libros.aggregate([
{ $group: { _id: "$genero", total: { $sum: 1 } } },
{ $sort: { total: -1 } }
])
3. Encontrar el libro más antiguo y el más reciente
db.libros.aggregate([
{ $group: {
_id: null,
mas_antiguo: { $min: "$fecha_publicacion" },
mas_reciente: { $max: "$fecha_publicacion" }
} }
])
4. Calcular el número promedio de años desde la publicación de los libros hasta la fecha actual
db.libros.aggregate([
{ $project: {
titulo: 1,
años_desde_publicacion: { $subtract: [new Date(), "$fecha_publicacion"] }
} },
{ $group: {
_id: null,
promedio_años: { $avg: { $divide: ["$años_desde_publicacion", 1000 * 60 * 60 * 24 * 365] } }
} }
])
5. Encontrar libros publicados por una editorial específica y contar cuántos hay
db.libros.aggregate([
{ $match: { editorial: "Viking Press" } },
{ $count: "total_libros" }
])
6. Listar los libros publicados después de 1950 y ordenarlos por fecha de publicación en orden descendente
db.libros.aggregate([
{ $match: { fecha_publicacion: { $gt: new Date("1950-01-01") } } },
{ $sort: { fecha_publicacion: -1 } }
])
7. Agrupar los libros por autor y listar los títulos de los libros que han escrito
db.libros.aggregate([
{ $group: {
_id: "$autor",
libros: { $push: "$titulo" }
} }
])
8. Calcular la cantidad de libros publicados por década
db.libros.aggregate([
{ $project: {
decada: { $substr: [ { $year: "$fecha_publicacion" }, 0, 3 ] }
} },
{ $group: {
_id: { $concat: ["$_id", "0s"] },
total: { $sum: 1 }
} }
])
9. Filtrar libros que tienen la palabra “El” en el título
db.libros.aggregate([
{ $match: { titulo: { $regex: /El/, $options: "i" } } }
])
10. Contar libros por autor y ordenar los autores por el número de libros en orden descendente
db.libros.aggregate([
{ $group: {
_id: "$autor",
total_libros: { $sum: 1 }
} },
{ $sort: { total_libros: -1 } }
])
Estos ejemplos muestran cómo utilizar las funcionalidades de agregación de MongoDB para realizar consultas complejas y obtener información específica de la colección de libros.
Proyecciones
Por supuesto, las proyecciones en MongoDB se utilizan para incluir o excluir campos específicos en los documentos devueltos por una consulta. Aquí tienes varios ejemplos de consultas con proyecciones utilizando la colección libros
:
1. Incluir solo el campo titulo
db.libros.find({}, { titulo: 1, _id: 0 }).pretty()
2. Incluir solo los campos titulo
y autor
db.libros.find({}, { titulo: 1, autor: 1, _id: 0 }).pretty()
3. Excluir el campo editorial
db.libros.find({}, { editorial: 0 }).pretty()
4. Incluir solo los campos titulo
, autor
y fecha_publicacion
db.libros.find({}, { titulo: 1, autor: 1, fecha_publicacion: 1, _id: 0 }).pretty()
5. Incluir solo el campo genero
db.libros.find({}, { genero: 1, _id: 0 }).pretty()
6. Incluir solo el campo titulo
y obtener los libros ordenados por fecha_publicacion
(ascendente)
db.libros.find({}, { titulo: 1, _id: 0 }).sort({ fecha_publicacion: 1 }).pretty()
7. Excluir el campo _id
db.libros.find({}, { _id: 0 }).pretty()
8. Incluir solo los campos titulo
y fecha_publicacion
para libros de un autor específico
db.libros.find({ autor: "George Orwell" }, { titulo: 1, fecha_publicacion: 1, _id: 0 }).pretty()
9. Incluir solo los campos titulo
y genero
para libros publicados después de 1950
db.libros.find({ fecha_publicacion: { $gt: new Date("1950-01-01") } }, { titulo: 1, genero: 1, _id: 0 }).pretty()
10. Incluir solo el campo autor
y contar cuántos libros tiene cada autor (proyección con agregación)
db.libros.aggregate([
{ $group: { _id: "$autor", total: { $sum: 1 } } },
{ $project: { autor: "$_id", total: 1, _id: 0 } }
])
11. Incluir solo los campos titulo
y editorial
para libros de un género específico
db.libros.find({ genero: "Realismo Mágico" }, { titulo: 1, editorial: 1, _id: 0 }).pretty()
12. Incluir solo los campos titulo
y fecha_publicacion
y excluir libros publicados antes de 1950
db.libros.find({ fecha_publicacion: { $gte: new Date("1950-01-01") } }, { titulo: 1, fecha_publicacion: 1, _id: 0 }).pretty()
13. Incluir solo el campo titulo
y mostrar los libros en orden descendente de fecha_publicacion
db.libros.find({}, { titulo: 1, _id: 0 }).sort({ fecha_publicacion: -1 }).pretty()
14. Incluir solo los campos titulo
, autor
y genero
para libros de una editorial específica
db.libros.find({ editorial: "Viking Press" }, { titulo: 1, autor: 1, genero: 1, _id: 0 }).pretty()
15. Incluir solo el campo genero
y contar cuántos libros hay en cada género (proyección con agregación)
db.libros.aggregate([
{ $group: { _id: "$genero", total: { $sum: 1 } } },
{ $project: { genero: "$_id", total: 1, _id: 0 } }
])
Estas proyecciones te permiten controlar qué campos se devuelven en los resultados de tus consultas, lo cual es útil para optimizar el rendimiento y la claridad de los datos que necesitas.
Ejemplos consultas MOngoDB
Claro, aquí tienes varios ejemplos de consultas que puedes realizar sobre la base de datos biblioteca
y la colección libros
:
1. Obtener todos los libros
db.libros.find().pretty()
2. Obtener un libro específico por su título
db.libros.findOne({ titulo: "1984" })
3. Obtener todos los libros de un autor específico
db.libros.find({ autor: "Gabriel García Márquez" }).pretty()
4. Obtener todos los libros publicados antes de un año específico
db.libros.find({ fecha_publicacion: { $lt: new Date("1950-01-01") } }).pretty()
5. Obtener todos los libros de un género específico
db.libros.find({ genero: "Fantasía" }).pretty()
6. Contar el número de libros en la colección
db.libros.countDocuments()
7. Obtener todos los libros ordenados por fecha de publicación (ascendente)
db.libros.find().sort({ fecha_publicacion: 1 }).pretty()
8. Obtener todos los libros ordenados por fecha de publicación (descendente)
db.libros.find().sort({ fecha_publicacion: -1 }).pretty()
9. Obtener todos los libros de un autor específico y ordenarlos por fecha de publicación
db.libros.find({ autor: "Gabriel García Márquez" }).sort({ fecha_publicacion: 1 }).pretty()
10. Obtener libros con un rango específico de fechas de publicación
db.libros.find({
fecha_publicacion: {
$gte: new Date("1930-01-01"),
$lte: new Date("1950-12-31")
}
}).pretty()
11. Actualizar el género de un libro específico
db.libros.updateOne(
{ titulo: "El Gran Gatsby" },
{ $set: { genero: "Novela Trágica" } }
)
12. Actualizar el autor de varios libros
db.libros.updateMany(
{ autor: "Gabriel García Márquez" },
{ $set: { autor: "G. García Márquez" } }
)
13. Eliminar un libro por su título
db.libros.deleteOne({ titulo: "La Metamorfosis" })
14. Eliminar todos los libros de un autor específico
db.libros.deleteMany({ autor: "G. García Márquez" })
15. Obtener libros con títulos que contengan una palabra específica (búsqueda por patrón)
db.libros.find({ titulo: /Cien/ }).pretty()
16. Obtener todos los libros publicados en un año específico
db.libros.find({ fecha_publicacion: { $gte: new Date("1967-01-01"), $lt: new Date("1968-01-01") } }).pretty()
17. Obtener todos los libros de una editorial específica
db.libros.find({ editorial: "Viking Press" }).pretty()
18. Agrupar libros por género y contar cuántos hay en cada grupo
db.libros.aggregate([
{ $group: { _id: "$genero", total: { $sum: 1 } } }
])
19. Encontrar libros cuyo título comienza con una letra específica
db.libros.find({ titulo: /^E/ }).pretty()
20. Obtener libros que no pertenezcan a un género específico
db.libros.find({ genero: { $ne: "Fantasía" } }).pretty()
Estas consultas te permiten explorar y manipular la colección libros
de diversas maneras, proporcionando una base sólida para trabajar con tus datos en MongoDB.
Ejemplos básicos mongodb
Comandos para crear la base de datos y la colección
Crea la base de datos y la colección:
use biblioteca
db.createCollection("libros")
Comandos para insertar 10 documentos de prueba
A continuación, insertarás 10 documentos con los campos titulo
, autor
, fecha_publicacion
, genero
, y editorial
.
db.libros.insertMany([
{ titulo: "Cien Años de Soledad", autor: "Gabriel García Márquez", fecha_publicacion: new Date("1967-05-30"), genero: "Realismo Mágico", editorial: "Sudamericana" },
{ titulo: "Don Quijote de la Mancha", autor: "Miguel de Cervantes", fecha_publicacion: new Date("1605-01-16"), genero: "Novela", editorial: "Francisco de Robles" },
{ titulo: "1984", autor: "George Orwell", fecha_publicacion: new Date("1949-06-08"), genero: "Distopía", editorial: "Secker & Warburg" },
{ titulo: "Matar a un ruiseñor", autor: "Harper Lee", fecha_publicacion: new Date("1960-07-11"), genero: "Drama", editorial: "J.B. Lippincott & Co." },
{ titulo: "El Gran Gatsby", autor: "F. Scott Fitzgerald", fecha_publicacion: new Date("1925-04-10"), genero: "Tragedia", editorial: "Charles Scribner's Sons" },
{ titulo: "Orgullo y Prejuicio", autor: "Jane Austen", fecha_publicacion: new Date("1813-01-28"), genero: "Romance", editorial: "T. Egerton" },
{ titulo: "En el camino", autor: "Jack Kerouac", fecha_publicacion: new Date("1957-09-05"), genero: "Novela", editorial: "Viking Press" },
{ titulo: "El Hobbit", autor: "J.R.R. Tolkien", fecha_publicacion: new Date("1937-09-21"), genero: "Fantasía", editorial: "George Allen & Unwin" },
{ titulo: "Fahrenheit 451", autor: "Ray Bradbury", fecha_publicacion: new Date("1953-10-19"), genero: "Ciencia ficción", editorial: "Ballantine Books" },
{ titulo: "La Metamorfosis", autor: "Franz Kafka", fecha_publicacion: new Date("1915-01-01"), genero: "Ficción", editorial: "Kurt Wolff Verlag" }
])
Comandos para verificar la inserción
Para asegurarte de que los documentos se han insertado correctamente, puedes usar el siguiente comando para mostrar todos los documentos en la colección:
db.libros.find().pretty()
Este comando mostrará todos los documentos de la colección libros
en un formato legible.
Comandos para realizar operaciones básicas
Leer (Read)
Mostrar todos los documentos de la colección:
db.libros.find().pretty()
Mostrar un libro específico por su título:
db.libros.findOne({ titulo: "1984" })
Actualizar (Update)
Actualizar la editorial de un libro específico:
db.libros.updateOne(
{ titulo: "El Hobbit" },
{ $set: { editorial: "Houghton Mifflin" } }
)
Eliminar (Delete)
Eliminar un libro específico por su título:
db.libros.deleteOne({ titulo: "La Metamorfosis" })
Estos comandos te permitirán gestionar una colección de libros en MongoDB desde la consola, realizando operaciones CRUD básicas y verificando los resultados.