Pequeñas correcciones a Conectores

sio2sio2 · sio2sio2 · commit 4c57d34c39ec · 2025-11-24T07:34:45.000+01:00
diff --git a/source/04.conector/01.basico.rst b/source/04.conector/01.basico.rst
@@ -132,8 +132,9 @@ El código tiene dos aspectos:
 Tampoco las sentencias de inserción devuelven resultados, por lo que supuesto
 que hayamos definido la clase ``Centro``:
 
-.. literalinclude:: files/CentroS.java
+.. literalinclude:: files/Centro.java
    :language: java
+   :name: clase-centro
    :class: toggle
    :caption: Centro.java
 
@@ -212,8 +213,8 @@ de objetos de Java, Por ejemplo, podríamos hacer esto:
           int id = rs.getInt("id");
           String nombre = rs.getString("nombre");
           String titularidad = rs.getString("titularidad");
-          // Posiblemente titularidad debería ser un enum.
-          centros.add(new Centro(id, nombre, titularidad));
+          // Quizás deberíamos comprobar que titularidad es válido.
+          centros.add(new Centro(id, nombre, Titularidad.fromString(titularidad)));
       }
    }
 
diff --git a/source/04.conector/02.datos.rst b/source/04.conector/02.datos.rst
@@ -23,23 +23,23 @@ equivalente propio de Java.
 .. table::
    :class: tipos-sql
 
-   +---------------------------+-------------------------+--------------------------------------+
-   | Tipo |SQL|                | Tipo Java\ [#]_         | Método |JDBC| de |PreparedStatement| |
-   +===========================+=========================+======================================+
-   | | CHAR(n)                 | :java-lang:`String`     | setString(int idx, String v)         |
-   | | VARCHAR(n)              |                         |                                      |
-   +---------------------------+-------------------------+--------------------------------------+
-   | | SMALLINT                | | :java-lang:`Short`    | | setShort(int idx, short v)         |
-   | | INTEGER                 | | :java-lang:`Integer`  | | setInt(int idx, int v)             |
-   | | BIGINT                  | | :java-lang:`Long`     | | setLong(int idx, long v)           |
-   +---------------------------+-------------------------+--------------------------------------+
-   | BOOLEAN                   | :java-lang:`Boolean`    | | setBoolean(int idx, boolean v)     |
-   +---------------------------+-------------------------+--------------------------------------+
-   | NUMERIC/DECIMAL\ [#]_     | :java-lang:`BigDecimal` | | setBigDecimal(int idx, BigDecimal) |
-   +---------------------------+-------------------------+--------------------------------------+
-   | | FLOAT, REAL\ [#]_       | | :java-lang:`Float`    | | setFloat(int idx, float v)         |
-   | | FLOAT, DOUBLE PRECISION | | :java-lang:`Double`   | | setDouble(int idx, double v)       |
-   +---------------------------+-------------------------+--------------------------------------+
+   +------------------------------+-------------------------+--------------------------------------+
+   | Tipo |SQL|                   | Tipo Java\ [#]_         | Método |JDBC| de |PreparedStatement| |
+   +==============================+=========================+======================================+
+   | | CHAR(n)                    | :java-lang:`String`     | setString(int idx, String v)         |
+   | | VARCHAR(n)                 |                         |                                      |
+   +------------------------------+-------------------------+--------------------------------------+
+   | | SMALLINT                   | | :java-lang:`Short`    | | setShort(int idx, short v)         |
+   | | INTEGER                    | | :java-lang:`Integer`  | | setInt(int idx, int v)             |
+   | | BIGINT                     | | :java-lang:`Long`     | | setLong(int idx, long v)           |
+   +------------------------------+-------------------------+--------------------------------------+
+   | BOOLEAN                      | :java-lang:`Boolean`    | | setBoolean(int idx, boolean v)     |
+   +------------------------------+-------------------------+--------------------------------------+
+   | NUMERIC/DECIMAL\ [#]_        | :java-lang:`BigDecimal` | | setBigDecimal(int idx, BigDecimal) |
+   +------------------------------+-------------------------+--------------------------------------+
+   | | FLOAT(n), REAL\ [#]_       | | :java-lang:`Float`    | | setFloat(int idx, float v)         |
+   | | FLOAT(n), DOUBLE PRECISION | | :java-lang:`Double`   | | setDouble(int idx, double v)       |
+   +------------------------------+-------------------------+--------------------------------------+
 
 .. note:: No hay más que sustituir `set` por `get` para obtener los métodos de
    |PreparedStatement| necesarios para guardar datos.
@@ -82,7 +82,7 @@ no es un tipo primitivo en Java, pero su uso es trivial:
       );
 
    Internamente, :program:`SQLite` sólo dispone de datos de tipo texto, entero (de
-   diverso tamaño), doble y BLOB; y dependiendo del valor que se suministre usará
+   diverso tamaño), doble y blob; y, dependiendo del valor que se suministre, usará
    un tipo u otro para el dato. Así, ``CHAR`` y ``VARCHAR`` se asimilan a texto,
    ``INTEGER``, ``BIGINT``, ``SMALLINT`` y ``BOOLEAN`` a enteros, ``FLOAT``,
    ``DOBLE`` y ``NUMERIC``/``DECIMAL`` a dobles (por tanto, se perderá la precisión
diff --git a/source/04.conector/10.extras.rst b/source/04.conector/10.extras.rst
@@ -17,6 +17,8 @@ simplificar la creación del pool y abstraernos de qué se usa para crearlo,
 podemos envolverlo en una clase como esta:
 
 .. literalinclude:: files/ConnectionPool.java
+   :class: toggle
+   :caption: ConnectionPool.java
    :name: clase-connectionpool
    :language: java
    :start-at: public class
@@ -45,6 +47,11 @@ mismos parámetros, devolverá el pool ya creado y no otro distinto:
    pool1 == pool4; // false
    ConnectionPool pool5 = PoolConnection.getInstance();  // IllegalArgumentException (hay dos, ¿cuál?)
 
+.. warning:: Obsérvese la |URL| que se ha utilizado en los ejemplos. En el caso
+   particular de *SQLite*, para que las distintas conexiones del *pool* abran
+   conexión a la misma base de datos en memoria, no basta con que la ruta sea
+   :file:`:memory:`, sino que ha de usarse :file:`file::memory:?cache=shared`.
+
 .. _conn-sqlutils:
 
 Tratamiento funcional de las consultas
@@ -57,30 +64,43 @@ paliarlo podemos definir una clase que haga la conversión (véase el
 
 .. literalinclude:: files/SqlUtils.java
    :language: java
+   :class: toggle
+   :caption: ConnectionPool.java
    :start-at: public class
 
-Si incluimos este archivo en nuestro proyecto podremos hacer consultas de este
-modo:
+la cual usa una excepción de usuario no protegida que debe estar también
+definida:
+
+.. literalinclude:: files/DataAccessRuntimeException.java
+   :language: java
+   :class: toggle
+   :caption: DataAccessRuntimeException.java
+
+Con estas clases y definiendo un método estático para convertir un registro de
+la tabla *Centro* (esto es, un |ResultSet|) en un objeto ``Centro``:
+
+.. code-block:: java
+
+   public static Centro resultSetToCentro(ResultSet rs) throws SQLException {
+      int id = rs.getInt("id");
+      String nombre = rs.getString("nombre");
+      Titularidad titularidad = Titularidad.fromString(rs.getString("titularidad"));
+      return new Centro(id, nombre, titularidad);
+   }
+
+se puede obtener un objeto :java-util:`Stream <stream/Stream>` que permita recorrer los
+resultados de la consulta:
 
 .. code-block:: java
-   :emphasize-lines: 6-14
+   :emphasize-lines: 6
 
    // No los cerramos, porque se encargara el cierre del flujo de hacerlo.
    Statement stmt = conn.createStatement();
    ResultSet rs = stmt.executeQuery("SELECT * FROM Centro");
-
-   try ( // try-with-resources para asegurarnos de liberar los recursos (stmt y rs)
-      Stream<Centro> centros = SqlUtils.resultSetToStream(stmt, rs, fila -> {
-         // Esta función puede generar un SQLException
-         int id = fila.getInt("id");
-         String nombre = fila.getString("nombre");
-         // Suponemos que hemos definido mejor Titularidad y hemos creado
-         // un método estático que obtiene Titularidad.PUBLICA a partir de "pública", etc.
-         Titularidad titularidad = Titularidad.fromNombre(fila.getString("titularidad"));
-         return new Centro(id, nombre, titularidad);
-      });
-   ) {
-      //Tratamos el flujo como estimemos más oportuno.
+ 
+   // try-with-resources para asegurarnos de liberar los recursos (stmt y rs)
+   try (Stream<Centro> centros = SqlUtils.resultSetToStream(stmt, rs, Main::resultToCentro)) {
+      // Tratamos el flujo como estimemos más oportuno.
       for(Centro c: (Iterable<Centro>) centros::iterator) {
          System.out.println(c);
       }
@@ -100,12 +120,7 @@ modo:
          Statement stmt = conn.createStatement();
          ResultSet rs = stmt.executeQuery("SELECT * FROM Centro");
       ) {
-         centros = SqlUtils.resultSetToStream(stmt, rs, fila -> {
-            int id = fila.getInt("id");
-            String nombre = fila.getString("nombre");
-            Titularidad titularidad = Titularidad.fromNombre(fila.getString("titularidad"));
-            return new Centro(id, nombre, titularidad);
-         });
+         centros = SqlUtils.resultSetToStream(stmt, rs, Main::resultToCentro);
       }
 
       for(Centro c: centros) {
@@ -129,7 +144,7 @@ modo:
    .. code-block:: java
 
       try(Stream<ResultSet> result = SqlUtils.resultSetToStream(stmt, rs)) {
-         // Tratamiento del rs (sin usar next, porque ya avanza el solo)
+         // Tratamos el resultado como un Stream.
       }
 
 .. _conn-transaction-manager:
diff --git a/source/04.conector/15.dao.rst b/source/04.conector/15.dao.rst
@@ -51,17 +51,8 @@ ambas manejan de igual modo su identificador:
 .. literalinclude:: files/Entity.java
    :name: clase-Entity
 
-La clase ``Centro`` es esta:
-
-.. literalinclude:: files/Centro.java
-   :language: java
-   :name: clase-centro
-   :caption: Centro.java
-   :class: toggle
-   :start-at: public class
-
-que incluye la definición del enum ``Titularidad``. La del ``Estudiante`` es esta
-otra:
+La clase :ref:`Centro <clase-centro>` ya se definió anteriormente.
+``Estudiante`` es esta otra:
 
 .. literalinclude:: files/Estudiante.java
    :language: java
diff --git a/source/04.conector/files/Centro.java b/source/04.conector/files/Centro.java
@@ -17,7 +17,8 @@ public static enum Titularidad {
             this.desc = desc;
         }
 
-        public String getDescripcion() {
+        @Override
+        public String toString() {
             return desc;
         }
 
@@ -26,9 +27,11 @@ public String getDescripcion() {
          * @param desc La descripción
          * @return El elemento Titularidad o null, si no hay ninguno con esa descripción.
          */
-        public static Titularidad fromDesc(String desc) {
+        public static Titularidad fromString(String desc) {
             return Arrays.stream(Titularidad.values())
-                .filter(t -> t.getDescripcion().compareToIgnoreCase(desc) == 0).findFirst().orElse(null);
+                .filter(t -> t.getDescripcion().compareToIgnoreCase(desc) == 0)
+                .findFirst()
+                .orElse(null);
         }
     }
 
diff --git a/source/04.conector/files/CentroS.java b/source/04.conector/files/CentroS.java
diff --git a/source/04.conector/files/DataAccessRuntimeException.java b/source/04.conector/files/DataAccessRuntimeException.java
@@ -0,0 +1,16 @@
+package edu.acceso.testjdbc;
+
+public class DataAccessRuntimeException extends RuntimeException {
+
+    public DataAccessRuntimeException(String message) {
+        super(message);
+    }
+
+    public DataAccessRuntimeException(Throwable e) {
+        super(e);
+    }
+
+    public DataAccessRuntimeException(String message, Throwable e) {
+        super(message, e);
+    }
+}
diff --git a/source/04.conector/files/SqlUtils.java b/source/04.conector/files/SqlUtils.java
@@ -22,12 +22,12 @@ public boolean hasNext() {
             if(avanzar) {
                 try {
                     if(rs.isClosed()) {
-                        throw new DataAccessException("ResultSet is closed!!!");
+                        throw new DataAccessRuntimeException("ResultSet is closed!!!");
                     }
                     hasNextElement = rs.next();
                 }
                 catch(SQLException err) {
-                    throw new DataAccessException(err);
+                    throw new DataAccessRuntimeException(err);
                 }
                 finally {
                     avanzar = false;
@@ -53,19 +53,19 @@ public static interface CheckedFunction<T, R> {
     }
 
     /**
-     * Transforma el SQLException que propaga una CheckedFUnction en un DataAccessException, que es una excepción
-     * que no necesita ser declarada.
+     * Transforma el SQLException que propaga una CheckedFUnction en un DataAccessRuntimeException,
+     * que es una excepción que no necesita ser declarada.
      * @param <T> El tipo que devuelve CheckedFunction.
      * @param checked Un "función" CheckedFunction.
-     * @return Una "función" que ha sustituido SQLException por DataAccessException.
+     * @return Una "función" que ha sustituido SQLException por DataAccessRuntimeException.
      */
     public static <T> Function<ResultSet, T> checkedToUnchecked(CheckedFunction<ResultSet, T> checked) {
         return t -> {
             try {
                 return checked.apply(t);
             }
             catch(SQLException err) {
-                throw new DataAccessException(err);
+                throw new DataAccessRuntimeException(err);
             }
         };
     }
@@ -88,7 +88,7 @@ public static Stream<ResultSet> resultSetToStream(AutoCloseable ac, ResultSet rs
                     ac.close();
                 }
                 catch(Exception err) {
-                    throw new DataAccessException(err);
+                    throw new DataAccessRuntimeException(err);
                 }
             });
     }
diff --git a/source/04.conector/files/resultSetToCentro.java b/source/04.conector/files/resultSetToCentro.java
@@ -0,0 +1,11 @@
+public static Centro resultSetToCentro(ResultSet rs) throws SQLException {
+
+   int id = rs.getInt("id");
+   String nombre = rs.getString("nombre");
+   // Suponemos que hemos definido mejor Titularidad y hemos creado
+   // un método estático que obtiene Titularidad.PUBLICA a partir de "pública", etc.
+   Titularidad titularidad = Titularidad.fromString(rs.getString("titularidad"));
+
+   return new Centro(id, nombre, titularidad);
+
+}

Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,8 @@ public static enum Titularidad {`
`17`	`17`	`this.desc = desc;`
`18`	`18`	`}`
`19`	`19`
`20`		`- public String getDescripcion() {`
	`20`	`+ @Override`
	`21`	`+ public String toString() {`
`21`	`22`	`return desc;`
`22`	`23`	`}`
`23`	`24`
`@@ -26,9 +27,11 @@ public String getDescripcion() {`
`26`	`27`	`* @param desc La descripción`
`27`	`28`	`* @return El elemento Titularidad o null, si no hay ninguno con esa descripción.`
`28`	`29`	`*/`
`29`		`- public static Titularidad fromDesc(String desc) {`
	`30`	`+ public static Titularidad fromString(String desc) {`
`30`	`31`	`return Arrays.stream(Titularidad.values())`
`31`		`- .filter(t -> t.getDescripcion().compareToIgnoreCase(desc) == 0).findFirst().orElse(null);`
	`32`	`+ .filter(t -> t.getDescripcion().compareToIgnoreCase(desc) == 0)`
	`33`	`+ .findFirst()`
	`34`	`+ .orElse(null);`
`32`	`35`	`}`
`33`	`36`	`}`
`34`	`37`
Original file line number	Diff line number	Diff line change
`@@ -22,12 +22,12 @@ public boolean hasNext() {`
`22`	`22`	`if(avanzar) {`
`23`	`23`	`try {`
`24`	`24`	`if(rs.isClosed()) {`
`25`		`- throw new DataAccessException("ResultSet is closed!!!");`
	`25`	`+ throw new DataAccessRuntimeException("ResultSet is closed!!!");`
`26`	`26`	`}`
`27`	`27`	`hasNextElement = rs.next();`
`28`	`28`	`}`
`29`	`29`	`catch(SQLException err) {`
`30`		`- throw new DataAccessException(err);`
	`30`	`+ throw new DataAccessRuntimeException(err);`
`31`	`31`	`}`
`32`	`32`	`finally {`
`33`	`33`	`avanzar = false;`
`@@ -53,19 +53,19 @@ public static interface CheckedFunction<T, R> {`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`/**`
`56`		`- * Transforma el SQLException que propaga una CheckedFUnction en un DataAccessException, que es una excepción`
`57`		`- * que no necesita ser declarada.`
	`56`	`+ * Transforma el SQLException que propaga una CheckedFUnction en un DataAccessRuntimeException,`
	`57`	`+ * que es una excepción que no necesita ser declarada.`
`58`	`58`	`* @param <T> El tipo que devuelve CheckedFunction.`
`59`	`59`	`* @param checked Un "función" CheckedFunction.`
`60`		`- * @return Una "función" que ha sustituido SQLException por DataAccessException.`
	`60`	`+ * @return Una "función" que ha sustituido SQLException por DataAccessRuntimeException.`
`61`	`61`	`*/`
`62`	`62`	`public static <T> Function<ResultSet, T> checkedToUnchecked(CheckedFunction<ResultSet, T> checked) {`
`63`	`63`	`return t -> {`
`64`	`64`	`try {`
`65`	`65`	`return checked.apply(t);`
`66`	`66`	`}`
`67`	`67`	`catch(SQLException err) {`
`68`		`- throw new DataAccessException(err);`
	`68`	`+ throw new DataAccessRuntimeException(err);`
`69`	`69`	`}`
`70`	`70`	`};`
`71`	`71`	`}`
`@@ -88,7 +88,7 @@ public static Stream<ResultSet> resultSetToStream(AutoCloseable ac, ResultSet rs`
`88`	`88`	`ac.close();`
`89`	`89`	`}`
`90`	`90`	`catch(Exception err) {`
`91`		`- throw new DataAccessException(err);`
	`91`	`+ throw new DataAccessRuntimeException(err);`
`92`	`92`	`}`
`93`	`93`	`});`
`94`	`94`	`}`