Connect to OceanBase Cloud by using a Druid connection pool

Click here to download the project code, which is a package named druid-mysql-client.zip.

Decompress the package to obtain a folder named druid-mysql-client. The directory structure is as follows:

druid-mysql-client
├── src
│   └── main
│       ├── java
│       │   └── com
│       │       └── example
│       │           └── Main.java
│       └── resources
│           └── db.properties
└── pom.xml

The files and directories are described as follows:

• src: the root directory that stores the source code.
• main: a directory that stores the main code, including the major logic of the application.
• java: a directory that stores the Java source code.
• com: a directory that stores the Java package.
• example: a directory that stores the packages of the sample project.
• Main.java: a sample file of the main class that contains logic such as the table creation, data insertion, data deletion, data modification, and data query logic.
• resources: a directory that stores resource files, including configuration files.
• db.properties: the configuration file of the connection pool, which contains relevant database connection parameters.
• pom.xml: the configuration file of the Maven project, which is used to manage project dependencies and build settings.

Code in pom.xml

pom.xml is the configuration file of the Maven project, which defines the dependencies, plug-ins, and build rules of the project. Maven is a Java project management tool that can automatically download dependencies and compile and package projects.

Perform the following steps to configure the pom.xml file:

1. Declare the file.

   Declare the file to be an XML file that uses XML standard 1.0 and the character encoding UTF-8.

   The sample code is as follows:

   <?xml version="1.0" encoding="UTF-8"?>
   

2. Configure namespaces and the POM model version.

   1. xmlns: the default XML namespace for the POM, which is set to http://maven.apache.org/POM/4.0.0.
   2. xmlns:xsi: the XML namespace for XML elements prefixed with xsi, which is set to http://www.w3.org/2001/XMLSchema-instance.
   3. xsi:schemaLocation: the location of an XML schema definition (XSD) file. The value consists of two parts: the default XML namespace (http://maven.apache.org/POM/4.0.0) and the URI of the XSD file (http://maven.apache.org/xsd/maven-4.0.0.xsd).
   4. <modelVersion>: the POM model version used by the POM file, which is set to 4.0.0.

   The sample code is as follows:

   <project xmlns="http://maven.apache.org/POM/4.0.0"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
   
    <!-- Other configurations -->
   
   </project>
   

3. Configure basic information.

   1. <groupId>: the ID of the group to which the project belongs, which is set to com.example.
   2. <artifactId>: the name of the project, which is set to druid-mysql-client.
   3. <version>: the project version, which is set to 1.0-SNAPSHOT.

   The sample code is as follows:

       <groupId>com.example</groupId>
       <artifactId>druid-mysql-client</artifactId>
       <version>1.0-SNAPSHOT</version>
   

4. Configure the attributes of the project source file.

   Specify maven-compiler-plugin as the compiler plug-in of Maven, and set the source code version and target code version of the compiler to Java 8. This means that the project source code is compiled by using Java 8 and the compiled bytecode is compatible with the Java 8 runtime environment. This ensures that Java 8 syntax and characteristics can be correctly processed during the compilation and running of the project.

   Note

   Java 1.8 and Java 8 are different names for the same version.

   The sample code is as follows:

       <build>
           <plugins>
               <plugin>
                   <groupId>org.apache.maven.plugins</groupId>
                   <artifactId>maven-compiler-plugin</artifactId>
                   <configuration>
                       <source>8</source>
                       <target>8</target>
                   </configuration>
               </plugin>
           </plugins>
       </build>
   

5. Configure the components on which the project depends.

   1. Add the mysql-connector-java dependency library for interactions with the database, and configure the following parameters:

      1. <groupId>: the ID of the group to which the dependency belongs, which is set to mysql.
      2. <artifactId>: the name of the dependency, which is set to mysql-connector-java.
      3. <version>: the version of the dependency, which is set to 5.1.40.

      The sample code is as follows:

              <dependency>
                  <groupId>mysql</groupId>
                  <artifactId>mysql-connector-java</artifactId>
                  <version>5.1.40</version>
              </dependency>
      

   2. Add the druid dependency library and configure the following parameters:

      1. <groupId>: the ID of the group to which the dependency belongs, which is set to com.alibaba.
      2. <artifactId>: the name of the dependency, which is set to druid.
      3. <version>: the version of the dependency, which is set to 1.2.8.

      The sample code is as follows:

              <dependency>
                  <groupId>com.alibaba</groupId>
                  <artifactId>druid</artifactId>
                  <version>1.2.8</version>
              </dependency>
      

Code in db.properties

db.properties is a sample configuration file of the connection pool. The configuration file contains the URL, username, and password for connecting to the database, and other optional parameters of the connection pool.

Perform the following steps to configure the db.properties file:

1. Configure database connection parameters.

   1. Specify the class name of the database driver as com.mysql.jdbc.Driver.
   2. Specify the URL for connecting to the database, including the host IP address, port number, and schema to be accessed.
   3. Specify the username for connecting to the database.
   4. Specify the password for connecting to the database.

   The sample code is as follows:

   driverClassName=com.mysql.jdbc.Driver
   url=jdbc:oceanbase://$host:$port/$database_name?useSSL=false
   username=$user_name
   password=$password
   

   The parameters are described as follows:

   • $host: the access address of OceanBase Cloud. The value is sourced from the -h parameter in the connection string.
   • $port: the access port of OceanBase Cloud. The value is sourced from the -P parameter in the connection string.
   • $database_name: the name of the database to be accessed. The value is sourced from the -D parameter in the connection string.
   • $user_name: the account name. The value is sourced from the -u parameter in the connection string.
   • $password: the account password. The value is sourced from the -p parameter in the connection string.

2. Configure other connection pool parameters.

   1. Specify select 1 as the SQL statement for connection verification.
   2. Set the number of initial connections in the connection pool to 3. When the connection pool is started, three initial connections are created.
   3. Set the maximum number of active connections allowed in the connection pool to 30.
   4. Set the value of the parameter that specifies whether to record logs for abandoned connections to true. This way, when an abandoned connection is recycled, an error log is recorded. We recommend that you set the value to true in a test environment and to false in an online environment to avoid compromising the performance.
   5. Set the minimum number of idle connections in the connection pool to 5. When the number of idle connections is less than 5, the connection pool automatically creates new connections.
   6. Set the maximum waiting time for requesting a connection to 1,000 ms. When the application requests a connection from the connection pool, if all connections are occupied, a timeout exception is thrown when the specified waiting time expires.
   7. Set the minimum duration for which a connection can remain idle in the connection pool to 300,000 ms. A connection that has been idle for 300,000 ms (5 minutes) will be recycled.
   8. Set the value of the parameter that specifies whether to recycle abandoned connections to true. An abandoned connection is recycled after the time specified by removeAbandonedTimeout elapses.
   9. Set the timeout value of an abandoned connection to 300s. An abandoned connection that has not been used in 300s (5 minutes) will be recycled.
   10. Set the interval for scheduling the idle connection recycling thread to 10,000 ms. In other words, the idle connection recycling thread is scheduled every 10,000 ms (10s) to recycle idle connections.
   11. Set the value of the parameter that specifies whether to verify a connection when it is requested to false. This can improve the performance. However, the obtained connection may be unavailable.
   12. Set the value of the parameter that specifies whether to verify a connection when it is returned to the connection pool to false. This can improve the performance. However, the connection returned to the connection pool may be unavailable.
   13. Set the value of the parameter that specifies whether to verify idle connections to true. When the value is set to true, the connection pool periodically executes the statement specified by validationQuery to verify the availability of connections.
   14. Set the value of the parameter that specifies whether to enable connection keepalive to false. The value false specifies to disable connection keepalive.
   15. Set the maximum idle period of connections to 60,000 ms. If the idle period of a connection exceeds 60,000 ms (1 minute), the connection keepalive mechanism will check the connection to ensure its availability. If any operation is performed in the connection during the idle period, the idle period is recounted.

   The sample code is as follows:

   validationQuery=select 1
   initialSize=3
   maxActive=30
   logAbandoned=true
   minIdle=5
   maxWait=1000
   minEvictableIdleTimeMillis=300000
   removeAbandoned=true
   removeAbandonedTimeout=300
   timeBetweenEvictionRunsMillis=10000
   testOnBorrow=false
   testOnReturn=false
   testWhileIdle=true
   keepAlive=false
   keepAliveBetweenTimeMillis=60000
   

General parameters of a Druid connection pool

Code in Main.java

The Main.java file is the main program of the sample application in this topic. It demonstrates how to use the data source, connection objects, and various database operation methods to interact with the database.

Perform the following steps to configure the Main.java file:

1. Import the required classes and interfaces.

   1. Declare the name of the package to which the current code belongs as com.example.
   2. Import the Java class IOException for handling input/output exceptions.
   3. Import the Java class InputStream for obtaining input streams from files or other sources.
   4. Import the Java interface Connection for representing connections with the database.
   5. Import the Java interface ResultSet for representing datasets of database query results.
   6. Import the Java class SQLException for handling SQL exceptions.
   7. Import the Java interface Statement for executing SQL statements.
   8. Import the Java interface PreparedStatement for representing precompiled SQL statements.
   9. Import the Java class Properties for processing the configuration file.
   10. Import the Java interface DataSource for managing database connections.
   11. Import the DruidDataSourceFactory class of Alibaba Druid for creating Druid data sources.

   The sample code is as follows:

   package com.example;
   
   import java.io.IOException;
   import java.io.InputStream;
   import java.sql.Connection;
   import java.sql.ResultSet;
   import java.sql.SQLException;
   import java.sql.Statement;
   import java.sql.PreparedStatement;
   import java.util.Properties;
   import javax.sql.DataSource;
   import com.alibaba.druid.pool.DruidDataSourceFactory;
   

2. Create a Main class and define a main method.

   Define a Main class and a main method. The main method demonstrates how to use the connection pool to execute a series of operations in the database. Perform the following steps:

   1. Define a public class named Main as the entry to the application. The class name must be the same as the file name.

   2. Define a public static method main as the entry to the application to receive command-line options.

   3. Capture and handle possible exceptions by using the exception handling mechanism.

   4. Call the loadPropertiesFile method to load the configuration file and return a Properties object.

   5. Call the createDataSource() method to create a data source object based on the configuration file.

   6. Use the try-with-resources block to obtain a database connection and automatically close the connection after use.

      1. Call the createTable() method to create a table.
      2. Call the insertData() method to insert data.
      3. Call the selectData() method to query data.
      4. Call the updateData() method to update data.
      5. Call the selectData() method again to query the updated data.
      6. Call the deleteData() method to delete data.
      7. Call the selectData() method again to query data after the deletion.
      8. Call the dropTable() method to drop the table.

   The sample code is as follows:

   public class Main {
   
       public static void main(String[] args) {
           try {
               Properties properties = loadPropertiesFile();
               DataSource dataSource = createDataSource(properties);
               try (Connection conn = dataSource.getConnection()) {
                   // Create a table.
                   createTable(conn);
                   // Insert data.
                   insertData(conn);
                   // Query data.
                   selectData(conn);
   
                   // Update data.
                   updateData(conn);
                   // Query the updated data.
                   selectData(conn);
   
                   // Delete data.
                   deleteData(conn);
                   // Query the data after deletion.
                   selectData(conn);
   
                   // Drop the table.
                   dropTable(conn);
               }
           } catch (Exception e) {
               e.printStackTrace();
           }
       }
   
       // Define a method for obtaining and using configurations in the configuration file.
       // Define a method for obtaining a data source object.
       // Define a method for creating tables.
       // Define a method for inserting data.
       // Define a method for updating data.
       // Define a method for deleting data.
       // Define a method for querying data.
       // Define a method for dropping tables.
   }
   

3. Define a method for obtaining and using configurations in the configuration file.

   Define a private static method loadPropertiesFile() for loading the configuration file and returning a Properties object. Perform the following steps:

   1. Define a private static method loadPropertiesFile() that returns a Properties object, and declare that the method can throw an IOException.
   2. Create a Properties object for storing key-value pairs in the configuration file.
   3. Use the try-with-resources block to obtain the input stream is of the db.properties configuration file by using the class loader.
   4. Call the load method to load attributes in the input stream to the properties object.
   5. Return the properties object.

   The sample code is as follows:

       private static Properties loadPropertiesFile() throws IOException {
           Properties properties = new Properties();
           try (InputStream is = Main.class.getClassLoader().getResourceAsStream("db.properties")) {
               properties.load(is);
           }
           return properties;
       }
   

4. Define a method for obtaining a data source object.

   Define a private static method createDataSource() for creating a DataSource object based on the configuration file. The object is used to manage and obtain database connections. Perform the following steps:

   1. Define a private static method createDataSource() that receives a Properties object as parameters, and declare that the method can throw an exception.
   2. Call the createDataSource() method of the DruidDataSourceFactory class, pass in the properties attribute, and return a DataSource object.

   The sample code is as follows:

       private static DataSource createDataSource(Properties properties) throws Exception {
           return DruidDataSourceFactory.createDataSource(properties);
       }
   

5. Define a method for creating tables.

   Define a private static method createTable() for creating tables in the database. Perform the following steps:

   1. Define a private static method createTable() that receives a Connection object as parameters, and declare that the method can throw an SQLException.
   2. Call the createStatement() method of the Connection object conn in the try-with-resources block to create a Statement object named stmt.
   3. Define a string variable sql for storing the table creation statement.
   4. Call the executeUpdate() method to execute the SQL statement to create a data table.
   5. Return a message indicating that the table is created.

   The sample code is as follows:

       private static void createTable(Connection conn) throws SQLException {
           try (Statement stmt = conn.createStatement()) {
               String sql = "CREATE TABLE test_druid (id INT, name VARCHAR(20))";
               stmt.executeUpdate(sql);
               System.out.println("Table created successfully.");
           }
       }
   

6. Define a method for inserting data.

   Define a private static method insertData() for inserting data into the database. Perform the following steps:

   1. Define a private static method insertData() that receives a Connection object as parameters, and declare that the method can throw an SQLException.

   2. Define a string variable insertDataSql for storing the data insertion statement.

   3. Define an integer variable insertedRows with the initial value 0, which is used to record the number of inserted rows.

   4. Use the prepareStatement() method of the Connection object conn and the data insertion statement in the try-with-resources block to create a PreparedStatement object named insertDataStmt.

   5. Use the FOR loop statement to perform five rounds of iterations to insert five data records.

      1. Call the setInt() method to set the value of the first parameter to the value of the loop variable i.
      2. Call the setString() method to set the value of the second parameter to the value of the test_insert string combined with the value of the loop variable i.
      3. Call the executeUpdate() method to execute the data insertion statement and add the number of operated rows to the value of the insertedRows variable.

   6. Return a message indicating that the data is inserted, with the total number of inserted rows displayed.

   7. Return the total number of inserted rows.

   The sample code is as follows:

       private static int insertData(Connection conn) throws SQLException {
           String insertDataSql = "INSERT INTO test_druid (id, name) VALUES (?, ?) ";
           int insertedRows = 0;
           try (PreparedStatement insertDataStmt = conn.prepareStatement(insertDataSql)) {
               for (int i = 1; i < 6; i++) {
                   insertDataStmt.setInt(1, i);
                   insertDataStmt.setString(2, "test_insert" + i);
                   insertedRows += insertDataStmt.executeUpdate();
               }
               System.out.println("Data inserted successfully. Inserted rows: " + insertedRows);
           }
           return insertedRows;
       }
   

7. Define a method for updating data.

   Define a private static method updateData() for updating data in the database. Perform the following steps:

   1. Define a private static method updateData() that receives a Connection object as parameters, and declare that the method can throw an SQLException.
   2. Use the prepareStatement() method of the Connection object conn and the data update statement in the try-with-resources block to create a PreparedStatement object named pstmt.
   3. Call the setString() method to set the value of the first parameter to test_update.
   4. Call the setInt() method to set the value of the second parameter to 3.
   5. Call the executeUpdate() method to execute the data update statement and assign the number of operated rows to the updatedRows variable.
   6. Return a message indicating that the data is updated, with the total number of updated rows displayed.

   The sample code is as follows:

       private static void updateData(Connection conn) throws SQLException {
           try (PreparedStatement pstmt = conn.prepareStatement("UPDATE test_druid SET name = ? WHERE id = ?" )) {
               pstmt.setString(1, "test_update");
               pstmt.setInt(2, 3);
               int updatedRows = pstmt.executeUpdate();
               System.out.println("Data updated successfully. Updated rows: " + updatedRows);
           }
       }
   

8. Define a method for deleting data.

   Define a private static method deleteData() for deleting data from the database. Perform the following steps:

   1. Define a private static method deleteData() that receives a Connection object as parameters, and declare that the method can throw an SQLException.
   2. Use the prepareStatement() method of the Connection object conn and the data deletion statement in the try-with-resources block to create a PreparedStatement object named pstmt.
   3. Call the setInt() method to set the value of the first parameter to 3.
   4. Call the executeUpdate() method to execute the data deletion statement and assign the number of operated rows to the deletedRows variable.
   5. Return a message indicating that the data is deleted, with the total number of deleted rows displayed.

   The sample code is as follows:

       private static void deleteData(Connection conn) throws SQLException {
           try (PreparedStatement pstmt = conn.prepareStatement("DELETE FROM test_druid WHERE id < ?" )) {
               pstmt.setInt(1, 3);
               int deletedRows = pstmt.executeUpdate();
               System.out.println("Data deleted successfully. Deleted rows: " + deletedRows);
           }
       }
   

9. Define a method for querying data.

   Define a private static method selectData() for querying data from the database. Perform the following steps:

   1. Define a private static method selectData() that receives a Connection object as parameters, and declare that the method can throw an SQLException.

   2. Call the createStatement() method of the Connection object conn in the try-with-resources block to create a Statement object named stmt.

   3. Define a string variable sql for storing the data query statement.

   4. Call the executeQuery() method to execute the data query statement and assign the returned result set to the resultSet variable.

   5. Use the WHILE loop statement to traverse each row in the result set.

      1. Call the getInt() method to obtain the integer value of the id field in the current row and assign the obtained value to the id variable.
      2. Call the getString() method to obtain the string value of the name field in the current row and assign the obtained value to the name variable.
      3. Return the values of the id and name fields in the current row.

   The sample code is as follows:

       private static void selectData(Connection conn) throws SQLException {
           try (Statement stmt = conn.createStatement()) {
               String sql = "SELECT * FROM test_druid";
               ResultSet resultSet = stmt.executeQuery(sql);
               while (resultSet.next()) {
                   int id = resultSet.getInt("id");
                   String name = resultSet.getString("name");
                   System.out.println("id: " + id + ", name: " + name);
               }
           }
       }
   

10. Define a method for dropping tables.

    Define a private static method dropTable() for dropping tables from the database. Perform the following steps:

    1. Define a private static method dropTable() that receives a Connection object as parameters, and declare that the method can throw an SQLException.
    2. Call the createStatement() method of the Connection object conn in the try-with-resources block to create a Statement object named stmt.
    3. Define a string variable sql for storing the table dropping statement.
    4. Call the executeUpdate() method to execute the table dropping statement.
    5. Return a message indicating that the table is dropped.

    The sample code is as follows:

        private static void dropTable(Connection conn) throws SQLException {
            try (Statement stmt = conn.createStatement()) {
                String sql = "DROP TABLE test_druid";
                stmt.executeUpdate(sql);
                System.out.println("Table dropped successfully.");
            }
        }
    

Complete code

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>druid-mysql-client</artifactId>
    <version>1.0-SNAPSHOT</version>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.40</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.8</version>
        </dependency>
    </dependencies>
</project>

# Database Configuration
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://$host:$port/$database_name?useSSL=false
username=$user_name
password=$password

# Connection Pool Configuration
#To check whether the database link is valid, MySQL must be configured to select 1; Oracle is select 1 from dual
validationQuery=select 1
#Initial number of connections
initialSize=3
#Maximum number of activations, that is, the maximum number of Connection pool
maxActive=30
#When closing the Abandoned connection, the error log is output. When the link is recycled, the console prints information. The test environment can add true, while the online environment is false. Will affect performance. When the link is recycled, the console prints information. The test environment can add true, while the online environment is false. Will affect performance.
logAbandoned=true
#Minimum number of activations during idle time
minIdle=5
#The maximum waiting time for a connection, in milliseconds
maxWait=1000
#The maximum time to start the eviction thread is the survival time of a link (previous value: 25200000, the converted result of this time is: 2520000/1000/60/60=7 hours)
minEvictableIdleTimeMillis=300000
#Whether to recycle after exceeding the time limit
removeAbandoned=true
#Exceeding the time limit (in seconds), currently 5 minutes. If any business processing time exceeds 5 minutes, it can be adjusted appropriately.
removeAbandonedTimeout=300
# Run the idle connection collector Destroy thread every 10 seconds to detect the interval time between connections, based on the judgment of testWhileIdle
timeBetweenEvictionRunsMillis=10000
#When obtaining a link, not verifying its availability can affect performance.
testOnBorrow=false
#Check whether the link is available when returning the link to the Connection pool.
testOnReturn=false
#This configuration can be set to true, without affecting performance and ensuring security. The meaning is: Detect when applying for a connection. If the idle time is greater than timeBetweenEviceRunsMillis, execute validationQuery to check if the connection is valid.
testWhileIdle=true
#Default false, if configured as true, connection detection will be performed in the DestroyConnectionThread thread (timeBetweenEvaluation once)
keepAlive=false
#If keepAlive rule takes effect and the idle time of the connection exceeds it, the connection will only be detected
keepAliveBetweenTimeMillis=60000

package com.example;

import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.PreparedStatement;
import java.util.Properties;
import javax.sql.DataSource;
import com.alibaba.druid.pool.DruidDataSourceFactory;

public class Main {

    public static void main(String[] args) {
        try {
            Properties properties = loadPropertiesFile();
            DataSource dataSource = createDataSource(properties);
            try (Connection conn = dataSource.getConnection()) {
                // Create a table.
                createTable(conn);
                // Insert data.
                insertData(conn);
                // Query data.
                selectData(conn);

                // Update data.
                updateData(conn);
                // Query the updated data.
                selectData(conn);

                // Delete data.
                deleteData(conn);
                // Query the data after deletion.
                selectData(conn);

                // Drop the table.
                dropTable(conn);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static Properties loadPropertiesFile() throws IOException {
        Properties properties = new Properties();
        try (InputStream is = Main.class.getClassLoader().getResourceAsStream("db.properties")) {
            properties.load(is);
        }
        return properties;
    }

    private static DataSource createDataSource(Properties properties) throws Exception {
        return DruidDataSourceFactory.createDataSource(properties);
    }

    private static void createTable(Connection conn) throws SQLException {
        try (Statement stmt = conn.createStatement()) {
            String sql = "CREATE TABLE test_druid (id INT, name VARCHAR(20))";
            stmt.executeUpdate(sql);
            System.out.println("Table created successfully.");
        }
    }

    private static int insertData(Connection conn) throws SQLException {
        String insertDataSql = "INSERT INTO test_druid (id, name) VALUES (?, ?) ";
        int insertedRows = 0;
        try (PreparedStatement insertDataStmt = conn.prepareStatement(insertDataSql)) {
            for (int i = 1; i < 6; i++) {
                insertDataStmt.setInt(1, i);
                insertDataStmt.setString(2, "test_insert" + i);
                insertedRows += insertDataStmt.executeUpdate();
            }
            System.out.println("Data inserted successfully. Inserted rows: " + insertedRows);
        }
        return insertedRows;
    }

    private static void updateData(Connection conn) throws SQLException {
        try (PreparedStatement pstmt = conn.prepareStatement("UPDATE test_druid SET name = ? WHERE id = ?" )) {
            pstmt.setString(1, "test_update");
            pstmt.setInt(2, 3);
            int updatedRows = pstmt.executeUpdate();
            System.out.println("Data updated successfully. Updated rows: " + updatedRows);
        }
    }

    private static void deleteData(Connection conn) throws SQLException {
        try (PreparedStatement pstmt = conn.prepareStatement("DELETE FROM test_druid WHERE id < ?" )) {
            pstmt.setInt(1, 3);
            int deletedRows = pstmt.executeUpdate();
            System.out.println("Data deleted successfully. Deleted rows: " + deletedRows);
        }
    }

    private static void selectData(Connection conn) throws SQLException {
        try (Statement stmt = conn.createStatement()) {
            String sql = "SELECT * FROM test_druid";
            ResultSet resultSet = stmt.executeQuery(sql);
            while (resultSet.next()) {
                int id = resultSet.getInt("id");
                String name = resultSet.getString("name");
                System.out.println("id: " + id + ", name: " + name);
            }
        }
    }

    private static void dropTable(Connection conn) throws SQLException {
        try (Statement stmt = conn.createStatement()) {
            String sql = "DROP TABLE test_druid";
            stmt.executeUpdate(sql);
            System.out.println("Table dropped successfully.");
        }
    }
}