02_java_jdbc_L_Avance.quarto_ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "---\n",
        "title: Accès avancé aux bases de données relationnelles en Java (JDBC)\n",
        "provide_notes: true\n",
        "provide_slides: true\n",
        "jupyter: java-lts\n",
        "echo: true\n",
        "output: true\n",
        "categories:\n",
        "  - Java\n",
        "  - I111\n",
        "  - Lecture\n",
        "  - JDBC\n",
        "---\n",
        "\n",
        "\n",
        "## Optimisation des Connexions à la Base de Données\n",
        "\n",
        "::: {.content-visible when-profile=\"slides\"}\n",
        "Pour optimiser les performances et l'utilisation des ressources, réutilisez les connexions à la base de données. Deux approches courantes :\n",
        "\n",
        "1. **DataSource**\n",
        "   - Utilisez une implémentation de `DataSource` pour gérer les connexions centralisées.\n",
        "2. **Pooling de Connexions**\n",
        "    - Utilisez des bibliothèques de pooling de connexions comme  **[Apache DBCP](http://commons.apache.org/proper/commons-dbcp/)** et **[C3P0](https://github.com/swaldman/c3p0)** pour réduire les coûts d'ouverture/fermeture des connexions.\n",
        "    - Réduction de la latence, meilleure gestion des ressources.\n",
        ":::\n",
        "\n",
        "::: {.content-visible when-profile=\"notes\"}\n",
        "La gestion des connexions à la base de données est cruciale pour garantir des performances optimales et une utilisation efficace des ressources. Au lieu d'ouvrir et de fermer des connexions pour chaque requête, il est recommandé de les réutiliser autant que possible. Voici deux approches courantes pour gérer les connexions :\n",
        "\n",
        "1. **DataSource** : Utilisez le concept de DataSource, qui fournit une interface centralisée pour gérer les connexions. Les serveurs d'applications et les frameworks tels que Spring proposent des implémentations de DataSource. Cela vous permet de configurer les paramètres de connexion (URL, nom d'utilisateur, mot de passe) une seule fois et de réutiliser ces connexions dans toute votre application.\n",
        "\n",
        "2. **[Apache DBCP](http://commons.apache.org/proper/commons-dbcp/)** et **[C3P0](https://github.com/swaldman/c3p0)** : Utilisez des bibliothèques de pooling de connexions comme Apache DBCP ou C3P0. Elles gèrent un pool de connexions réutilisables, ce qui évite les coûts de création et de fermeture des connexions à chaque requête. Elles offrent également des fonctionnalités telles que la surveillance des connexions, la configuration des limites de pool et la gestion des connexions inactives.\n",
        "\n",
        "En adoptant l'une de ces approches, vous améliorerez la gestion des connexions à la base de données, réduirez la latence et optimiserez les performances de votre application.\n",
        ":::\n",
        "\n",
        "L'utilisation est simple on définit une classe qui paramètre une datasource qui gère un pool de connexion et fournit des connections : \n"
      ],
      "id": "e1856607"
    },
    {
      "cell_type": "code",
      "metadata": {
        "vscode": {
          "languageId": "java"
        }
      },
      "source": [
        "%maven org.apache.commons:commons-dbcp2:2.13.0"
      ],
      "id": "93629f54",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "vscode": {
          "languageId": "java"
        }
      },
      "source": [
        "import org.apache.commons.dbcp2.BasicDataSource;\n",
        "import java.sql.Connection;\n",
        "import java.sql.SQLException;\n",
        "\n",
        "public class DBCPDataSource {\n",
        "\n",
        "    // Création d'un pool de connexions avec BasicDataSource\n",
        "    private static BasicDataSource ds = new BasicDataSource();\n",
        "\n",
        "    static {\n",
        "        // Configuration des paramètres de connexion\n",
        "        ds.setUrl(\"jdbc:postgresql://docker/gtfs\"); // URL de la base de données\n",
        "        ds.setUsername(System.getenv(\"DB_USERNAME\")); // Nom d'utilisateur (récupéré depuis les variables d'environnement)\n",
        "        ds.setPassword(System.getenv(\"DB_PASSWORD\")); // Mot de passe (récupéré depuis les variables d'environnement)\n",
        "\n",
        "        // Configuration du pool de connexions\n",
        "        ds.setMinIdle(5); // Nombre minimal de connexions inactives dans le pool\n",
        "        ds.setMaxIdle(10); // Nombre maximal de connexions inactives dans le pool\n",
        "        ds.setMaxOpenPreparedStatements(100); // Nombre maximal de requêtes préparées ouvertes simultanément\n",
        "    }\n",
        "\n",
        "    // Constructeur privé pour empêcher l'instanciation directe de la classe\n",
        "    private DBCPDataSource() {\n",
        "    }\n",
        "\n",
        "    // Méthode statique pour obtenir une connexion à partir du pool\n",
        "    public static Connection getConnection() throws SQLException {\n",
        "        return ds.getConnection();\n",
        "    }\n",
        "}"
      ],
      "id": "67319606",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Il suffit ensuite de demander et de rendre une connexion (le close ne ferme pas forcément la connexion).\n"
      ],
      "id": "8f965f80"
    },
    {
      "cell_type": "code",
      "metadata": {
        "vscode": {
          "languageId": "java"
        }
      },
      "source": [
        "// Connexion à la base de données et récupération des métadonnées du ResultSet\n",
        "try (Connection connection = DBCPDataSource.getConnection();\n",
        "     ResultSet rs = connection.createStatement().executeQuery(\"SELECT * FROM stops\")) {\n",
        "\n",
        "    // Récupération de l'objet ResultSetMetaData\n",
        "    ResultSetMetaData rsmd = rs.getMetaData();\n",
        "    int nbColonnes = rsmd.getColumnCount();\n",
        "\n",
        "    // Parcours des colonnes et affichage des informations\n",
        "    for (int i = 1; i <= nbColonnes; i++) {\n",
        "        String typeColonne = rsmd.getColumnTypeName(i);\n",
        "        String nomColonne = rsmd.getColumnName(i);\n",
        "        System.out.println(\"Colonne \" + i + \" de nom \" + nomColonne + \" de type \" + typeColonne);\n",
        "    }\n",
        "} catch (SQLException e) {\n",
        "    e.printStackTrace();\n",
        "}"
      ],
      "id": "751fa4a1",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## La couche DAO (Data Access Object) en Java JDBC\n",
        "\n",
        "::: {.content-visible when-profile=\"notes\"}\n",
        "Le pattern DAO (Data Access Object) est un composant fondamental de l'architecture des applications Java qui interagissent avec une base de données. Il répond à plusieurs problématiques essentielles du développement d'applications :\n",
        "\n",
        "La couche DAO agit comme une interface entre l'application et la base de données. Elle permet d'isoler complètement la logique métier des détails techniques de la persistance des données. Cette séparation offre plusieurs avantages :\n",
        "- Maintenance facilitée du code\n",
        "- Possibilité de changer de système de persistance sans impacter le code métier\n",
        "- Centralisation de la gestion des erreurs liées à la base de données\n",
        "\n",
        "L'implémentation d'une couche DAO repose généralement sur deux composants principaux :\n",
        "\n",
        "1. **Interface générique**\n",
        "   Cette interface définit un contrat standard pour les opérations CRUD (Create, Read, Update, Delete). L'utilisation des génériques Java permet d'adapter l'interface à différents types d'entités tout en maintenant une structure commune.\n",
        "\n",
        "2. **Classes d'implémentation**\n",
        "   Chaque entité métier dispose de sa propre classe DAO qui implémente l'interface générique. Ces classes contiennent la logique spécifique d'accès aux données, notamment :\n",
        "\n",
        "   - Les requêtes SQL paramétrées\n",
        "   - La gestion des connexions\n",
        "   - La transformation des résultats en objets métier\n",
        "   - La gestion des exceptions\n",
        "\n",
        "Pour une implémentation robuste de la couche DAO, il est recommandé de :\n",
        "\n",
        "- Utiliser des requêtes préparées pour prévenir les injections SQL\n",
        "- Gérer proprement les ressources (connexions, statements, resultsets)\n",
        "- Transformer les exceptions SQL en exceptions métier\n",
        "- Documenter clairement les comportements attendus\n",
        "- Implémenter des tests unitaires pour chaque DAO\n",
        ":::\n",
        "\n",
        "::: {.content-visible when-profile=\"slides\"}\n",
        "- Objectif de la couche DAO (Data Access Object)\n",
        "  - Abstraire l'accès aux données pour isoler la logique métier de la persistance.\n",
        "  - Centraliser les opérations spécifiques liées à la persistance des données.\n",
        "- Associations entre entités et classes DAO\n",
        "  - Chaque entité (par exemple, une table dans la base de données) peut être associée à une classe DAO.\n",
        "  - Évite la répétition de code pour les opérations CRUD (Create, Read, Update, Delete).\n",
        "- Implémentation de base pour une DAO\n",
        "  1. **Interface générique** :\n",
        "     - Définir une interface avec les méthodes CRUD (create, read, update, delete).\n",
        "     - Exemple : `DAO<T>`.\n",
        "  2. **Classe générique** :\n",
        "     - Implémenter cette interface dans une classe par entité (par exemple, `DogDAO implements DAO<Dog>`).\n",
        "     - Utiliser une classe asbtraite pour factoriser le code commun.\n",
        "     - Utiliser des requêtes SQL paramétrées pour les opérations.\n",
        "     - Gérer les exceptions spécifiques (transformer les exceptions SQL en exceptions applicatives).\n",
        ":::\n",
        "\n",
        "### Interface générique DAO\n"
      ],
      "id": "e2810347"
    },
    {
      "cell_type": "code",
      "metadata": {
        "vscode": {
          "languageId": "java"
        }
      },
      "source": [
        "public interface GenericDAO<T, ID> {\n",
        "    void create(T entity) throws SQLException;\n",
        "    T read(ID id) throws SQLException;\n",
        "    void update(T entity) throws SQLException;\n",
        "    void delete(ID id) throws SQLException;\n",
        "    List<T> findAll() throws SQLException;\n",
        "}"
      ],
      "id": "f7d04903",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Implantation concrète DAO\n"
      ],
      "id": "f56cb842"
    },
    {
      "cell_type": "code",
      "metadata": {
        "vscode": {
          "languageId": "java"
        }
      },
      "source": [
        "// Record User pour représenter l'entité utilisateur\n",
        "public record User(Integer id, String name, String email) {}\n",
        "\n",
        "// Implémentation concrète de UserDAO\n",
        "public class UserDAO implements GenericDAO<User, Integer> {\n",
        "    private Connection connection;\n",
        "\n",
        "    public UserDAO(Connection connection) {\n",
        "        this.connection = connection;\n",
        "    }\n",
        "\n",
        "    @Override\n",
        "    public void create(User user) throws SQLException {\n",
        "        String sql = \"INSERT INTO users (name, email) VALUES (?, ?)\";\n",
        "        try (PreparedStatement pstmt = connection.prepareStatement(sql)) {\n",
        "            pstmt.setString(1, user.name());\n",
        "            pstmt.setString(2, user.email());\n",
        "            pstmt.executeUpdate();\n",
        "        }\n",
        "    }\n",
        "\n",
        "    @Override\n",
        "    public User read(Integer id) throws SQLException {\n",
        "        String sql = \"SELECT * FROM users WHERE id = ?\";\n",
        "        try (PreparedStatement pstmt = connection.prepareStatement(sql)) {\n",
        "            pstmt.setInt(1, id);\n",
        "            try (ResultSet rs = pstmt.executeQuery()) {\n",
        "                if (rs.next()) {\n",
        "                    return new User(rs.getInt(\"id\"), rs.getString(\"name\"), rs.getString(\"email\"));\n",
        "                }\n",
        "            }\n",
        "        }\n",
        "        return null;\n",
        "    }\n",
        "\n",
        "    @Override\n",
        "    public void update(User user) throws SQLException {\n",
        "        String sql = \"UPDATE users SET name = ?, email = ? WHERE id = ?\";\n",
        "        try (PreparedStatement pstmt = connection.prepareStatement(sql)) {\n",
        "            pstmt.setString(1, user.name());\n",
        "            pstmt.setString(2, user.email());\n",
        "            pstmt.setInt(3, user.id());\n",
        "            pstmt.executeUpdate();\n",
        "        }\n",
        "    }\n",
        "\n",
        "    @Override\n",
        "    public void delete(Integer id) throws SQLException {\n",
        "        String sql = \"DELETE FROM users WHERE id = ?\";\n",
        "        try (PreparedStatement pstmt = connection.prepareStatement(sql)) {\n",
        "            pstmt.setInt(1, id);\n",
        "            pstmt.executeUpdate();\n",
        "        }\n",
        "    }\n",
        "\n",
        "    @Override\n",
        "    public List<User> findAll() throws SQLException {\n",
        "        List<User> users = new ArrayList<>();\n",
        "        String sql = \"SELECT * FROM users\";\n",
        "        try (Statement stmt = connection.createStatement();\n",
        "             ResultSet rs = stmt.executeQuery(sql)) {\n",
        "            while (rs.next()) {\n",
        "                users.add(new User(rs.getInt(\"id\"), rs.getString(\"name\"), rs.getString(\"email\")));\n",
        "            }\n",
        "        }\n",
        "        return users;\n",
        "    }\n",
        "}"
      ],
      "id": "840bf5aa",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Création d'une base de données simple\n"
      ],
      "id": "e4d4c2a4"
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "%maven com.h2database:h2:2.3.232\n",
        "%maven com.github.javafaker:javafaker:1.0.2\n",
        "import com.github.javafaker.Faker;"
      ],
      "id": "dd2781fd",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "vscode": {
          "languageId": "java"
        }
      },
      "source": [
        "private static final String DB_URL = \"jdbc:h2:mem:testdb\";\n",
        "private static final String DB_USERNAME = \"sa\";\n",
        "private static final String DB_PASSWORD = \"\";\n",
        "\n",
        "Class.forName(\"org.h2.Driver\");\n",
        "\n",
        "private static void createTables(Connection connection) throws SQLException {\n",
        "    String createUsersTableSql = \"CREATE TABLE users (\" +\n",
        "            \"id INT AUTO_INCREMENT PRIMARY KEY,\" +\n",
        "            \"name VARCHAR(255) NOT NULL,\" +\n",
        "            \"email VARCHAR(255) NOT NULL)\";\n",
        "    try (Statement statement = connection.createStatement()) {\n",
        "        statement.execute(createUsersTableSql);\n",
        "    }\n",
        "}\n",
        "\n",
        "private static void populateTables(Connection connection) throws SQLException {\n",
        "    Faker faker = new Faker();\n",
        "    String insertUsersSql = \"INSERT INTO users (name, email) VALUES (?, ?)\";\n",
        "\n",
        "    try (PreparedStatement pstmt = connection.prepareStatement(insertUsersSql)) {\n",
        "        IntStream.range(0, 10).forEach(i -> {\n",
        "            try {\n",
        "                pstmt.setString(1, faker.name().fullName());\n",
        "                pstmt.setString(2, faker.internet().emailAddress());\n",
        "                pstmt.executeUpdate();\n",
        "            } catch (SQLException e) {\n",
        "                throw new RuntimeException(e);\n",
        "            }\n",
        "        });\n",
        "    }\n",
        "}"
      ],
      "id": "2dd06c1c",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Utilisation de la DAO\n"
      ],
      "id": "21ca182d"
    },
    {
      "cell_type": "code",
      "metadata": {},
      "source": [
        "try (Connection connection = DriverManager.getConnection(DB_URL, DB_USERNAME, DB_PASSWORD)) {\n",
        "    createTables(connection);\n",
        "    populateTables(connection);\n",
        "    System.out.println(\"Database setup completed successfully.\");\n",
        "\n",
        "    // Utilisation de UserDAO pour effectuer des opérations CRUD\n",
        "    UserDAO userDAO = new UserDAO(connection);\n",
        "\n",
        "    // Création d'utilisateurs\n",
        "    userDAO.create(new User(null, \"Alice\", \"alice@example.com\"));\n",
        "    userDAO.create(new User(null, \"Bob\", \"bob@example.com\"));\n",
        "\n",
        "    // Lecture d'un utilisateur\n",
        "    User user = userDAO.read(1);\n",
        "    System.out.println(\"Read user: \" + user);\n",
        "\n",
        "    // Mise à jour d'un utilisateur\n",
        "    userDAO.update(new User(1, \"Alice Updated\", \"alice.updated@example.com\"));\n",
        "\n",
        "    // Suppression d'un utilisateur\n",
        "    userDAO.delete(2);\n",
        "\n",
        "    // Lecture de tous les utilisateurs\n",
        "    List<User> users = userDAO.findAll();\n",
        "    users.forEach(System.out::println);\n",
        "\n",
        "} catch (SQLException e) {\n",
        "    e.printStackTrace();\n",
        "}"
      ],
      "id": "ffdbd8fb",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Metadata\n",
        "\n",
        "::: {.content-visible when-profile=\"slides\"}\n",
        "* JDBC permet de récupérer des informations sur le type de données que l'on vient de récupérer par un SELECT (interface ResultSetMetaData),\n",
        "* mais aussi sur la base de données elle-même (interface DatabaseMetaData)\n",
        "* Les données que l'on peut récupérer avec DatabaseMetaData dépendent du SGBD avec lequel on travaille\n",
        ":::\n",
        "\n",
        "::: {.content-visible when-profile=\"notes\"}\n",
        "JDBC offre des fonctionnalités puissantes pour récupérer des informations à partir d'une base de données. \n",
        "\n",
        "**`ResultSetMetaData`** : Cette interface permet d'obtenir des informations sur les résultats d'une requête SELECT. Vous pouvez récupérer des détails tels que le nombre de colonnes, les noms des colonnes, les types de données, les précisions, les échelles, etc. Cela facilite la manipulation des résultats et l'adaptation de votre code en fonction des données récupérées.\n",
        "\n",
        "**`DatabaseMetaData`** : Cette interface fournit des informations sur la base de données elle-même, indépendamment des requêtes spécifiques. Vous pouvez obtenir des détails sur les tables, les colonnes, les index, les contraintes, les utilisateurs, les privilèges, etc. Les données accessibles via `DatabaseMetaData` varient en fonction du SGBD (Système de Gestion de Bases de Données) avec lequel vous travaillez. Par exemple, certaines bases de données peuvent fournir plus d'informations que d'autres.\n",
        ":::\n"
      ],
      "id": "0b170c0c"
    },
    {
      "cell_type": "code",
      "metadata": {
        "vscode": {
          "languageId": "java"
        }
      },
      "source": [
        "//| echo: false\n",
        "//| output: false\n",
        "String DB_URL=\"jdbc:postgresql://docker/gtfs\";\n",
        "String DB_USERNAME=Optional.of(System.getenv(\"DB_USERNAME\")).orElseThrow(()->new IllegalArgumentException(\"DB_USERNAME is required\"));\n",
        "String DB_PASSWORD=Optional.of(System.getenv(\"DB_PASSWORD\")).orElseThrow(()->new IllegalArgumentException(\"DB_PASSWORD is required\"));\n",
        "%maven org.postgresql:postgresql:42.7.3"
      ],
      "id": "b168ffeb",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Exemple de récupération des métadonnées de la base de données\n"
      ],
      "id": "857aa53d"
    },
    {
      "cell_type": "code",
      "metadata": {
        "vscode": {
          "languageId": "java"
        }
      },
      "source": [
        "try (Connection connection = DriverManager.getConnection(DB_URL, DB_USERNAME, DB_PASSWORD)) {\n",
        "\n",
        "    // Récupération des métadonnées de la base de données\n",
        "    DatabaseMetaData metadata = connection.getMetaData();\n",
        "\n",
        "    // Affichage des informations sur le système de gestion de base de données\n",
        "    System.out.printf(\"DBMS: %s %d.%d%n\",\n",
        "            metadata.getDatabaseProductName(),\n",
        "            metadata.getDatabaseMajorVersion(),\n",
        "            metadata.getDatabaseMinorVersion());\n",
        "\n",
        "    // Affichage de la base de données et du schéma actuels\n",
        "    System.out.printf(\"Current Database: %s Schema: %s%n\",\n",
        "            connection.getCatalog(), connection.getSchema());\n",
        "\n",
        "    // Récupération de la liste des tables pour vérifier l'existence de \"SIMPLEJDBC_PERSON\"\n",
        "    ResultSet tables = metadata.getTables(connection.getCatalog(),\n",
        "            connection.getSchema(),\n",
        "            \"SIMPLEJDBC_PERSON\", null);\n",
        "\n",
        "    if (tables.next()) {\n",
        "        // Si la table existe déjà, affichage d'un message\n",
        "        System.out.println(\"Table \" + tables.getString(\"TABLE_NAME\") + \" already exists.\");\n",
        "    } else {\n",
        "        // Si la table n'existe pas, création de la table \"SIMPLEJDBC_PERSON\"\n",
        "        String createTableSql = \"CREATE TABLE \\\"SIMPLEJDBC_PERSON\\\"(\" +\n",
        "                \"id INT PRIMARY KEY NOT NULL, \" +\n",
        "                \"firstname VARCHAR(100))\";\n",
        "        try (Statement statement = connection.createStatement()) {\n",
        "            statement.execute(createTableSql);\n",
        "            System.out.println(\"Table SIMPLEJDBC_PERSON created.\");\n",
        "        }\n",
        "    }\n",
        "\n",
        "} catch (SQLException e) {\n",
        "    // Gestion des exceptions SQL\n",
        "    e.printStackTrace();\n",
        "}"
      ],
      "id": "5f0c5f27",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Exemple de récupération des métadonnées du `ResultSet`\n"
      ],
      "id": "e3e020c7"
    },
    {
      "cell_type": "code",
      "metadata": {
        "vscode": {
          "languageId": "java"
        }
      },
      "source": [
        "// Connexion à la base de données et récupération des métadonnées du ResultSet\n",
        "try (Connection connection = DriverManager.getConnection(DB_URL, DB_USERNAME, DB_PASSWORD);\n",
        "     ResultSet rs = connection.createStatement().executeQuery(\"SELECT * FROM stops\")) {\n",
        "\n",
        "    // Récupération de l'objet ResultSetMetaData pour obtenir des informations sur les colonnes\n",
        "    ResultSetMetaData rsmd = rs.getMetaData();\n",
        "    int nbColonnes = rsmd.getColumnCount();\n",
        "\n",
        "    // Parcours des colonnes et affichage des informations\n",
        "    for (int i = 1; i <= nbColonnes; i++) {\n",
        "        String typeColonne = rsmd.getColumnTypeName(i); // Type de la colonne\n",
        "        String nomColonne = rsmd.getColumnName(i);      // Nom de la colonne\n",
        "        System.out.printf(\"Colonne %d: nom = %s, type = %s%n\", i, nomColonne, typeColonne);\n",
        "    }\n",
        "} catch (SQLException e) {\n",
        "    // Gestion des exceptions SQL\n",
        "    e.printStackTrace();\n",
        "}"
      ],
      "id": "d014dfb8",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Exemple de récupération des métadonnées des colonnes d'une table\n"
      ],
      "id": "682908e2"
    },
    {
      "cell_type": "code",
      "metadata": {
        "vscode": {
          "languageId": "java"
        }
      },
      "source": [
        "import java.sql.*;\n",
        "import java.util.stream.IntStream;\n",
        "\n",
        "// Connexion à la base de données et récupération des métadonnées du ResultSet\n",
        "try (Connection connection = DriverManager.getConnection(DB_URL, DB_USERNAME, DB_PASSWORD);\n",
        "     ResultSet rs = connection.createStatement().executeQuery(\"SELECT * FROM stops LIMIT 5\")) {\n",
        "\n",
        "    // Récupération de l'objet ResultSetMetaData pour obtenir des informations sur les colonnes\n",
        "    ResultSetMetaData rsmd = rs.getMetaData();\n",
        "    int nbColonnes = rsmd.getColumnCount();\n",
        "\n",
        "    // Affichage des noms de colonnes\n",
        "    IntStream.range(1, nbColonnes + 1)\n",
        "             .mapToObj(i -> {\n",
        "                 try {\n",
        "                     return rsmd.getColumnName(i)+\" \"+rsmd.getColumnTypeName(i);\n",
        "                 } catch (SQLException e) {\n",
        "                     throw new RuntimeException(e);\n",
        "                 }\n",
        "             })\n",
        "             .forEach(nomColonne -> System.out.printf(\"%-20s\", nomColonne));\n",
        "    System.out.println();\n",
        "\n",
        "    // Affichage des données des lignes\n",
        "    while (rs.next()) {\n",
        "        IntStream.range(1, nbColonnes + 1)\n",
        "                 .mapToObj(i -> {\n",
        "                     try {\n",
        "                         return rs.getString(i);\n",
        "                     } catch (SQLException e) {\n",
        "                         throw new RuntimeException(e);\n",
        "                     }\n",
        "                 })\n",
        "                 .forEach(valeur -> System.out.printf(\"%-20s\", valeur));\n",
        "        System.out.println();\n",
        "    }\n",
        "\n",
        "} catch (SQLException e) {\n",
        "    // Gestion des exceptions SQL\n",
        "    e.printStackTrace();\n",
        "}"
      ],
      "id": "b28bdf95",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## ResultSet modifiables\n",
        "\n",
        "Il est aussi possible de paramétrer un ResultSet pour qu'il soit modifiable pendant la consultation et/ou que l'on puisse revenir en arrière.\n"
      ],
      "id": "b5b87b54"
    },
    {
      "cell_type": "code",
      "metadata": {
        "vscode": {
          "languageId": "java"
        }
      },
      "source": [
        "try (Connection connection = DriverManager.getConnection(DB_URL, DB_USERNAME, DB_PASSWORD);\n",
        "     ResultSet rs = connection.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE)\n",
        "         .executeQuery(\"SELECT * FROM agency\")) {\n",
        "\n",
        "    // Affichage des données initiales\n",
        "    System.out.println(\"Données initiales:\");\n",
        "    while (rs.next()) {\n",
        "        System.out.printf(\"ID: %s, Nom: %s%n\", rs.getString(\"agency_id\"), rs.getString(\"agency_name\"));\n",
        "    }\n",
        "\n",
        "    // Mise à jour d'un enregistrement\n",
        "    rs.beforeFirst(); // Revenir au début du ResultSet\n",
        "    while (rs.next()) {\n",
        "        if (rs.getString(\"agency_name\").equalsIgnoreCase(\"Réseau Mistral\")) {\n",
        "            rs.updateString(\"agency_name\", \"Agence Université Updated\");\n",
        "            rs.updateRow();\n",
        "        }\n",
        "    }\n",
        "\n",
        "    // Ajout d'un nouvel enregistrement\n",
        "    rs.moveToInsertRow();\n",
        "    rs.updateString(\"agency_id\", \"9999\");\n",
        "    rs.updateString(\"agency_name\", \"New Agency\");\n",
        "    rs.updateString(\"agency_url\", \"http://newagency.com\");\n",
        "    rs.updateString(\"agency_timezone\", \"Europe/Paris\");\n",
        "    rs.insertRow();\n",
        "\n",
        "    // Suppression d'un enregistrement\n",
        "    rs.beforeFirst(); // Revenir au début du ResultSet\n",
        "    while (rs.next()) {\n",
        "        if (rs.getString(\"agency_name\").equalsIgnoreCase(\"Neverland\")) {\n",
        "            rs.deleteRow();\n",
        "        }\n",
        "    }\n",
        "\n",
        "    // Affichage des données mises à jour\n",
        "    rs.beforeFirst(); // Revenir au début du ResultSet\n",
        "    System.out.println(\"Données mises à jour:\");\n",
        "    while (rs.next()) {\n",
        "        System.out.printf(\"ID: %s, Nom: %s%n\", rs.getString(\"agency_id\"), rs.getString(\"agency_name\"));\n",
        "    }\n",
        "\n",
        "} catch (SQLException e) {\n",
        "    // Gestion des exceptions SQL\n",
        "    e.printStackTrace();\n",
        "}"
      ],
      "id": "6f0887fe",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Batch Update\n",
        "\n",
        "Lorsque vous effectuez des ajouts en masse, envisagez d’utiliser les mises à jour par lots. Cependant, soyez prudent avec les transactions.\n"
      ],
      "id": "58e38a5d"
    },
    {
      "cell_type": "code",
      "metadata": {
        "vscode": {
          "languageId": "java"
        }
      },
      "source": [
        "try (Connection connection = DriverManager.getConnection(DB_URL, DB_USERNAME, DB_PASSWORD)) {\n",
        "     \n",
        "  //Création d'une table PERSONNE\n",
        "  String createAccountTableSql=\"CREATE TABLE PERSONNE (\"+\n",
        "    \"id SERIAL PRIMARY KEY,\"+\n",
        "    \"email VARCHAR(100) NOT NULL,\"+\n",
        "    \"nom VARCHAR(100) NOT NULL,\"+\n",
        "    \"prenom VARCHAR(100) NOT NULL)\";\n",
        "  Statement statement = connection.createStatement();\n",
        "  statement.executeUpdate(createAccountTableSql);\n",
        "  statement.close();     \n",
        "     \n",
        "  PreparedStatement pstmt = \n",
        "        connection.prepareStatement(\"INSERT INTO PERSONNE (email, nom, prenom) VALUES(?, ?, ?)\");\n",
        " \n",
        "  //On ajoute les exécution une à une ...\n",
        "  connection.setAutoCommit(false);\n",
        " \n",
        "  // On fixe les paramètres de la première requête à exécuter\n",
        "  pstmt.setString( 1, \"p1.n1@...\");\n",
        "  pstmt.setString( 2, \"n1\" );\n",
        "  pstmt.setString( 3, \"p1\" );\n",
        "  // Et on l'ajoute au batch\n",
        "  pstmt.addBatch();\n",
        " \n",
        "  // On fixe les paramètres de la seconde requête à exécuter\n",
        "  pstmt.setString( 1, \"p2.n2@...\");\n",
        "  pstmt.setString( 2, \"n2\" );\n",
        "  pstmt.setString( 3, \"p2\" );\n",
        "  // Et on l'ajoute au batch\n",
        "  pstmt.addBatch();\n",
        " \n",
        "  // On ajoute autant de requêtes que nécessaire\n",
        "  //Par exemple en lisant un flux de données.\n",
        "\n",
        "\n",
        "  //On créée un tableau d'entiers pour recevoir les résultats.\n",
        "  //et on execute toutes les mises à jour en une fois.\n",
        "  int[] affectedRecords = pstmt.executeBatch();\n",
        " \n",
        "  System.out.println(Arrays.toString(affectedRecords));\n",
        "    \n",
        "  //On valide les changements.\n",
        "  connection.commit();\n",
        "    \n",
        "  //Drop the table\n",
        "  connection.createStatement().executeUpdate(\"DROP TABLE PERSONNE\");    \n",
        "}    "
      ],
      "id": "40d3cf67",
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "kernelspec": {
      "name": "java-lts",
      "language": "java",
      "display_name": "java-lts",
      "path": "/opt/conda/share/jupyter/kernels/java-lts"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}