Connect to OceanBase Database by using a Proxool connection pool

This topic introduces how to build an application by using a Proxool connection pool, OceanBase Connector/J, and OceanBase Database. It also covers the use of the application for fundamental database operations, including table creation, data insertion, data deletion, data updating, and data query.

Download the proxool-oceanbase-client sample project

Prerequisites

• You have installed OceanBase Database and created an Oracle tenant.

• You have installed Java Development Kit (JDK) 1.8 and Maven.

• You have installed IntelliJ IDEA.

  Note

  The tool used to run the sample code in this topic is IntelliJ IDEA 2021.3.2 (Community Edition), but you can also choose a tool that suits your personal preference to run the code.

Procedure

1. Import the proxool-oceanbase-client project into IntelliJ IDEA.
2. Obtain the URL of OceanBase Database.
3. Modify the database connection information in the proxool-oceanbase-client project.
4. Run the proxool-oceanbase-client project.

Step 1: Import the proxool-oceanbase-client project into IntelliJ IDEA

1. Start IntelliJ IDEA.

2. On the welcome page, click Open, navigate to the directory where the project is located, select the root directory of the project, and click OK.

   

3. IntelliJ IDEA automatically detects the project type and loads the project.

   Note

   When you import a Maven project using IntelliJ IDEA, it will automatically detect the pom.xml file in the project, download the required dependency libraries based on the described dependencies in the file, and add them to the project.

   

4. (Optional) Manually import the unparsed dependencies.

   If the dependencies in the pom.xml file are automatically imported to the project, ignore this step.

   The information in the Sync pane of IntelliJ IDEA shows that the proxool-cglib and proxool dependencies are not parsed. The .jar files of the proxool-cglib and proxool dependencies are located in the lib folder of the root directory of the proxool-oceanbase-client project. Perform the following steps to add these files to the project:

   1. In IntelliJ IDEA, choose File > Project Structure.
   2. In the left-side pane, click Modules.
   3. In the right-side pane, click the Dependencies tab. On this tab, click the plus sign (+) and choose JARs or directories.
   4. In the dialog box that appears, navigate to the lib directory where the .jar files are stored, select the .jar files, and click OK.
   5. The added .jar files appear in the list on the Dependencies tab.
   6. Click Apply or OK to save the changes.

   

Step 2: Obtain the URL of OceanBase Database

1. Contact the deployment personnel or administrator of OceanBase Database to obtain the connection string.

   Here is an example:

   obclient -hxxx.xxx.xxx.xxx -P2881 -utest_user001@oracel001 -p******
   

   For more information about the connection string, see Connect to an OceanBase tenant by using OBClient.

2. Fill in the URL below based on the OceanBase Database connection string.

   jdbc:oceanbase://$host:$port/$schema_name?user=$user_name&password=$password
   

   where

   • $host specifies the IP address for connecting to OceanBase Database. For connection through OceanBase Database Proxy (ODP), this parameter is the IP address of an ODP. For direct connection, this parameter is the IP address of an OBServer node.

   • $port specifies the port for connecting to OceanBase Database. For connection through ODP, the default value is 2883, which can be customized when ODP is deployed. For direct connection, the default value is 2881, which can be customized when OceanBase Database is deployed.

   • $schema_name specifies the name of the schema to be accessed.

     Notice

     The user used to connect to the tenant must have the CREATE SESSION privilege and the CREATE TABLE, INSERT, DELETE, UPDATE, and SELECT privileges on this schema. For more information about user privileges, see Privilege types in Oracle mode.

   • $user_name specifies the tenant account. For connection through ODP, the tenant account can be in the username@tenant name#cluster name or cluster name:tenant name:username format. For direct connection, the tenant account is in the username@tenant name format.

   • $password specifies the password of the account.

   For more information about URL parameters in OceanBase Connector/J, see Database URL.

   Here is an example:

   jdbc:oceanbase://xxx.xxx.xxx.xxx:2881/test_schema001?user=test_user001@oracel001&password=******
   

Step 3: Modify the database connection information in the proxool-oceanbase-client project

Modify the database connection information in the proxool-oceanbase-client/src/main/resources/db.properties file based on the information obtained in Step 2.

Here is an example:

• The IP address of the OBServer node is xxx.xxx.xxx.xxx.
• The port is 2881.
• The name of the schema to be accessed is test_schema001.
• The tenant account is test_user001@oracle001, where oracle001 is an Oracle user tenant created in OceanBase Database, and test_user001 is the username of the oracle001 tenant.
• The password is ******.

The sample code is as follows:

...
jdbc-1.proxool.driver-url=jdbc:oceanbase://xxx.xxx.xxx.xxx:2881/test_schema001
jdbc-1.user=test_user001@oracle001
jdbc-1.password=******
...

Step 4: Run the proxool-oceanbase-client project

1. In the navigation pane of the project, locate and expand the src/main/java/com.example directory.

2. Right-click the Main file and choose Run 'Main.main()'.

3. IntelliJ IDEA automatically compiles and runs this project and displays the output results on the running panel.

   

4. You can also execute the following SQL statement in OceanBase Client (OBClient) to view the results:

   obclient [TEST_USER001]> SELECT * FROM test_schema001.test_proxool;
   

   The return result is as follows:

   +------+---------------+
   | C1   | C2            |
   +------+---------------+
   |    6 | test_update   |
   |    7 | test_insert7  |
   |    8 | test_insert8  |
   |    9 | test_insert9  |
   |   10 | test_insert10 |
   +------+---------------+
   5 rows in set
   

Project code introduction

Click proxool-oceanbase-client to download the project code, which is a compressed file named proxool-oceanbase-client.zip.

After decompressing it, you will find a folder named proxool-oceanbase-client. The directory structure is as follows:

proxool-oceanbase-client
├── lib
│    ├── proxool-0.9.1.jar
│    └── proxool-cglib.jar
├── src
│   └── main
│       ├── java
│       │   └── com
│       │       └── example
│       │           └── Main.java
│       └── resources
│           └── db.properties
└── pom.xml

Here is a breakdown of the files and directories:

• lib: the directory for storing the dependency libraries required by the project.
• proxool-0.9.1.jar: library files of the Proxool connection pool.
• proxool-cglib.jar: CGLib files for the Proxool connection pool.
• src: the root directory for storing the source code.
• main: the directory for storing the main code, including the major logic of the application.
• java: the directory for storing the Java source code.
• com: the directory for storing the Java package.
• example: the directory for storing the packages of the sample project.
• Main.java: a sample file of the main class that contains logic for table creation, data insertion, data deletion, data modification, and data query.
• resources: the directory for storing 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 the pom.xml file

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

To configure the pom.xml file, perform the following steps:

1. Declare the file.

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

   The sample code is as follows:

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

2. Configure the namespaces and the POM model version.

   1. xmlns: the default XML namespace, which is set to http://maven.apache.org/POM/4.0.0.
   2. xmlns:xsi: the namespace for XML elements prefixed with xsi, which is set to http://www.w3.org/2001/XMLSchema-instance.
   3. xsi:schemaLocation: the mapping between the XML namespace and its corresponding XML schema definition (XSD) file. The value typically consists of paired strings separated by spaces. Each pair consists of a default XML namespace (http://maven.apache.org/POM/4.0.0) in the first part, and the URI of the corresponding XSD file (http://maven.apache.org/xsd/maven-4.0.0.xsd) in the second part.
   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 proxool-oceanbase-client.
   3. <version>: the project version, which is set to 1.0-SNAPSHOT.

   The sample code is as follows:

       <groupId>com.example</groupId>
       <artifactId>proxool-oceanbase-client</artifactId>
       <version>1.0-SNAPSHOT</version>
   

4. Configure the properties of the project's source file.

   Specify the Maven compiler plug-in as maven-compiler-plugin, and set both the source code and target Java versions to 8. This means that the project's source code is written using Java 8, and the compiled bytecode will also be compatible with the Java 8 runtime environment. This setup ensures that the project can correctly handle the syntax and features of Java 8 during compilation and runtime.

   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 oceanbase-client library for connecting to and operating the database and configure the following parameters:

      1. <groupId>: the ID of the group to which the dependency belongs, which is set to com.oceanbase.
      2. <artifactId>: the name of the dependency, which is set to oceanbase-client.
      3. <version>: the version of the dependency, which is set to 2.4.2.

      Note

      The following code defines that the project depends on OceanBase Connector/J V2.4.2. For more information about other versions, see OceanBase Connector/J.

      The sample code is as follows:

              <dependency>
                  <groupId>com.oceanbase</groupId>
                  <artifactId>oceanbase-client</artifactId>
                  <version>2.4.2</version>
              </dependency>
      

   2. Add the proxool-cglib dependency library, which is a CGLib library for the Proxool connection pool, and configure the following parameters:

      1. <groupId>: the ID of the group to which the dependency belongs, which is set to proxool.
      2. <artifactId>: the name of the dependency, which is set to proxool-cglib.
      3. <version>: the version of the dependency, which is set to 0.9.1.

      The sample code is as follows:

              <dependency>
                  <groupId>proxool</groupId>
                  <artifactId>proxool-cglib</artifactId>
                  <version>0.9.1</version>
              </dependency>
      

   3. Add the proxool dependency library, which is the core library of the Proxool connection pool, and configure the following parameters:

      1. <groupId>: the ID of the group to which the dependency belongs, which is set to proxool.
      2. <artifactId>: the name of the dependency, which is set to proxool.
      3. <version>: the version of the dependency, which is set to 0.9.1.

      The sample code is as follows:

              <dependency>
                  <groupId>proxool</groupId>
                  <artifactId>proxool</artifactId>
                  <version>0.9.1</version>
              </dependency>
      

   4. Add the commons-logging dependency library, which is a general log library for recording logs in the application, and configure the following parameters:

      1. <groupId>: the ID of the group to which the dependency belongs, which is set to commons-logging.
      2. <artifactId>: the name of the dependency, which is set to commons-logging.
      3. <version>: the version of the dependency, which is set to 1.2.

      The sample code is as follows:

              <dependency>
                  <groupId>commons-logging</groupId>
                  <artifactId>commons-logging</artifactId>
                  <version>1.2</version>
              </dependency>
      

Code in the db.properties file

db.properties is a sample configuration file for the connection pool, containing the configuration properties for the connection pool.

The db.properties file in this topic is a sample configuration file used to configure the connection pool properties of a data source named jdbc-1. Perform the following steps to configure the db.properties file:

1. Set the alias of the data source to TEST.

   The sample code is as follows:

   jdbc-1.proxool.alias=TEST
   

2. Configure database connection parameters.

   1. Specify the class name of the driver, which is set to the class name com.oceanbase.jdbc.Driver of OceanBase Connector/J.
   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:

   jdbc-1.proxool.driver-class=com.oceanbase.jdbc.Driver
   jdbc-1.proxool.driver-url=jdbc:oceanbase://$host:$port/$schema_name
   jdbc-1.user=$user_name
   jdbc-1.password=$password
   

   where

   • $host specifies the IP address for connecting to OceanBase Database. For connection through OceanBase Database Proxy (ODP), this parameter is the IP address of an ODP. For direct connection, this parameter is the IP address of an OBServer node.
   • $port specifies the port for connecting to OceanBase Database. For connection through ODP, the default value is 2883, which can be customized when ODP is deployed. For direct connection, the default value is 2881, which can be customized when OceanBase Database is deployed.
   • $schema_name specifies the name of the schema to be accessed.
   • $user_name specifies the tenant account. For connection through ODP, the tenant account can be in the username@tenant name#cluster name or cluster name:tenant name:username format. For direct connection, the tenant account is in the username@tenant name format.
   • $password specifies the password of the account.

3. Configure other parameters of the Proxool connection pool.

   1. Set the maximum number of connections in the connection pool to 8.
   2. Set the minimum number of connections in the connection pool to 5.
   3. Set the number of available connections in the connection pool to 4.
   4. Enable the Verbose mode to show more log information.
   5. Set the statistics collection cycles of the connection pool to 10s, 1 minute, and 1 day.
   6. Set the log level of the statistics to ERROR.

   The sample code is as follows:

   jdbc-1.proxool.maximum-connection-count=8
   jdbc-1.proxool.minimum-connection-count=5
   jdbc-1.proxool.prototype-count=4
   jdbc-1.proxool.verbose=true
   jdbc-1.proxool.statistics=10s,1m,1d
   jdbc-1.proxool.statistics-log-level=error
   

The following table describes the general parameters.

Code in the Main.java file

The Main.java file is a part of the sample application, demonstrating how to obtain a database connection through the Proxool connection pool and perform a series of database operations. These operations include creating a table, inserting data, deleting data, updating data, querying data, and printing the query results.

To configure the Main.java file, perform the following steps:

1. Import the required classes and interfaces.

   Define the package where the code resides and import relevant Proxool and JDBC classes. These classes are used to configure and manage the database connection pool and execute SQL statements. The Proxool connection pool can improve the database performance and reliability. The specific steps are as follows:

   1. Define the package where the code resides as com.example. This package stores the current Java classes.
   2. Import the Proxool configuration class org.logicalcobwebs.proxool.configuration.PropertyConfigurator.
   3. Import the input stream class java.io.InputStream for reading configuration files.
   4. Import the JDBC Connection class java.sql.Connection.
   5. Import the JDBC DriverManager class java.sql.DriverManager.
   6. Import the JDBC ResultSet class java.sql.ResultSet.
   7. Import the JDBC Statement class java.sql.Statement.
   8. Import the Properties class java.util.Properties for loading configuration files.

   The sample code is as follows:

   package com.example;
   
   import org.logicalcobwebs.proxool.configuration.PropertyConfigurator;
   import java.io.InputStream;
   import java.sql.Connection;
   import java.sql.DriverManager;
   import java.sql.ResultSet;
   import java.sql.Statement;
   import java.util.Properties;
   

2. Define class names and methods.

   Define an entry method for Java applications. Obtain the database connection information from the configuration file. After establishing a database connection by using the Proxool driver, call the defined methods in sequence to execute DDL, DML, and query statements. Capture possible exceptions and record stack information of the exceptions. This code segment aims to execute database operations and record logs by using the log recorder. The specific steps are as follows:

   1. Define a public class named Main.

      1. Define a private static constant named DB_PROPERTIES_FILE to indicate the path where the database configuration file is located. This constant can be referenced in code to load and read the configuration file.

      2. Define a public static method named main, which is used as the execution start point of the application.

         1. Capture code blocks with possible exceptions.

            1. Create a Properties object for reading property values from the configuration file.
            2. Use the class loader of the Main class to obtain the input stream of the configuration file.
            3. Use the input stream to load the properties in the configuration file to the Properties object.
            4. Configure the connection pool based on the loaded property values.
            5. Dynamically load the Proxool database driver.
            6. Establish a database connection by using the Proxool driver.
            7. Create a Statement object.
            8. Call the defined method executeDDLStatements() to execute a DDL statement to create a table.
            9. Call the defined method executeDMLStatements() to execute DML statements to insert, update, and delete data.
            10. Call the defined method executeQueryStatements() to execute a query statement to obtain data.

         2. Capture and return possible exceptions.

   2. Define methods for creating tables, executing DML statements, and querying data.

   The sample code is as follows:

   public class Main {
       private static final String DB_PROPERTIES_FILE = "/db.properties";
   
       public static void main(String[] args) {
           try {
               Properties properties = new Properties();
               InputStream is = Main.class.getResourceAsStream(DB_PROPERTIES_FILE);
               properties.load(is);
               PropertyConfigurator.configure(properties);
   
               Class.forName("org.logicalcobwebs.proxool.ProxoolDriver");
               try (Connection conn = DriverManager.getConnection("proxool.TEST");
                   Statement stmt = conn.createStatement()) {
                   executeDDLStatements(stmt);
                   executeDMLStatements(stmt);
                   executeQueryStatements(stmt);
               }
           } catch (Exception e) {
               e.printStackTrace();
           }
       }
   
       // Define a method for creating tables.
       // Define a method for executing DML statements.
       // Define a method for querying data.
   }
   

3. Define a method for creating tables.

   Define a private static method executeDDLStatements() for executing DDL statements, including table creation statements. The specific steps are as follows:

   1. Define a private static method executeDDLStatements(). The method receives a Statement object as a parameter and can throw an Exception.
   2. Call the execute() method to execute an SQL statement to create a table named test_proxool. The table has two columns: c1 and c2, which are respectively of the NUMBER and VARCHAR2(32) types.

   The sample code is as follows:

       private static void executeDDLStatements(Statement stmt) throws Exception {
           stmt.execute("CREATE TABLE test_proxool (c1 NUMBER, c2 VARCHAR2(32))");
       }
   

4. Define a method for executing DML statements.

   Define a private static method executeDMLStatements() for executing DML statements to insert, delete, and update data. The specific steps are as follows:

   1. Define a private static method executeDMLStatements(). The method receives a Statement object as a parameter. If an exception occurs during the execution, the method throws an Exception.
   2. Use the FOR loop to perform 10 rounds of iterations. In the loop, call the execute() method to execute an INSERT statement to insert the i variable and relevant string values into the test_proxool table.
   3. Execute a DELETE statement to delete rows whose c1 column values are smaller than or equal to 5 from the test_proxool table.
   4. Execute an UPDATE statement to update the c2 column values of the rows in the test_proxool table whose c1 column values are 6 to test_update.

   The sample code is as follows:

       private static void executeDMLStatements(Statement stmt) throws Exception {
           for (int i = 1; i <= 10; i++) {
               stmt.execute("INSERT INTO test_proxool VALUES (" + i + ",'test_insert" + i + "')");
           }
           stmt.execute("DELETE FROM test_proxool WHERE c1 <= 5");
           stmt.execute("UPDATE test_proxool SET c2 = 'test_update' WHERE c1 = 6");
       }
   

5. Define a method for querying data.

   Define a private static method executeQueryStatements() for executing the SELECT statement and processing the result. The specific steps are as follows:

   1. Define a private static method executeQueryStatements(). The method receives a Statement object as a parameter. If an exception occurs during the execution, the method throws an Exception.
   2. Call the executeQuery() method to execute a SELECT statement and store the result in a ResultSet object named rs. Here, all data in the test_proxool table is returned for the query. Execute the try-with-resources block and make sure that the ResultSet object is automatically closed after being used.
   3. Use the WHILE loop and the next() method to iterate through each row of data in the ResultSet object named rs. In each iteration, the rs.next() method moves the pointer to the next row of the result set. If there is another row of data available, the method returns true; otherwise, it returns false. In the WHILE loop, as long as rs.next() returns true, it indicates that more rows of data are available. The code within the loop will then execute and handle the data of the current row. When all rows of data have been processed, rs.next() will return false, and the loop will end.
   4. Call the getInt() and getString() methods to obtain the values of specified columns in the current row and return the values to the console. Here, the values of the c1 and c2 columns are returned. Call the getInt() method to obtain integer values and call the getString() method to obtain string values.

   The sample code is as follows:

       private static void executeQueryStatements(Statement stmt) throws Exception {
           try (ResultSet rs = stmt.executeQuery("SELECT * FROM test_proxool")) {
               while (rs.next()) {
                   System.out.println(rs.getInt("c1") + "   " + rs.getString("c2"));
               }
           }
       }
   

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.oceanbase</groupId>
    <artifactId>proxool-oceanbase-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>com.oceanbase</groupId>
            <artifactId>oceanbase-client</artifactId>
            <version>2.4.2</version>
        </dependency>
        <dependency>
            <groupId>proxool</groupId>
            <artifactId>proxool-cglib</artifactId>
            <version>0.9.1</version>
        </dependency>
        <dependency>
            <groupId>proxool</groupId>
            <artifactId>proxool</artifactId>
            <version>0.9.1</version>
        </dependency>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
    </dependencies>
</project>

#alias: the alias of the data source
jdbc-1.proxool.alias=TEST
#driver-class: driver name
jdbc-1.proxool.driver-class=com.oceanbase.jdbc.Driver
#driver-url: url connection string, username and password must be determined
jdbc-1.proxool.driver-url=jdbc:oceanbase://$host:$port/$schema_name
jdbc-1.user=$user_name
jdbc-1.password=$password
#The maximum number of database connections. The default is 15
jdbc-1.proxool.maximum-connection-count=8
#The minimum number of database connections, defaults to 5
jdbc-1.proxool.minimum-connection-count=5
#The number of available connections in the Connection pool. If the number of connections in the current Connection pool is less than this value, new connections will be established (assuming that the maximum number of available connections is not exceeded). For example, if we have three active connections and two available connections, and our prototype count is 4, the database Connection pool will try to establish another two connections. This is different from the minimum connection count Minimum connection count also counts active connections. Prototype count is the number of spare connections
jdbc-1.proxool.prototype-count=4
#verbose: detailed information settings. Parameter bool value
jdbc-1.proxool.verbose=true
#statistics: connection pool usage statistics. Parameter "10s, 1m, 1d"
jdbc-1.proxool.statistics=10s,1m,1d
#statistics-log-level:  log statistics tracking type. Parameter 'ERROR' or 'INFO'
jdbc-1.proxool.statistics-log-level=error

package com.example;

import org.logicalcobwebs.proxool.configuration.PropertyConfigurator;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.Properties;

public class Main {
    private static final String DB_PROPERTIES_FILE = "/db.properties";

    public static void main(String[] args) {
        try {
            Properties properties = new Properties();
            InputStream is = Main.class.getResourceAsStream(DB_PROPERTIES_FILE);
            properties.load(is);
            PropertyConfigurator.configure(properties);

            Class.forName("org.logicalcobwebs.proxool.ProxoolDriver");
            try (Connection conn = DriverManager.getConnection("proxool.TEST");
                Statement stmt = conn.createStatement()) {
                executeDDLStatements(stmt);
                executeDMLStatements(stmt);
                executeQueryStatements(stmt);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static void executeDDLStatements(Statement stmt) throws Exception {
        stmt.execute("CREATE TABLE test_proxool (c1 NUMBER, c2 VARCHAR2(32))");
    }

    private static void executeDMLStatements(Statement stmt) throws Exception {
        for (int i = 1; i <= 10; i++) {
            stmt.execute("INSERT INTO test_proxool VALUES ("+ i +",'test_insert" + i + "')");
        }
        stmt.execute("DELETE FROM test_proxool WHERE c1 <= 5");
        stmt.execute("UPDATE test_proxool SET c2 = 'test_update' WHERE c1 = 6");
    }

    private static void executeQueryStatements(Statement stmt) throws Exception {
        try (ResultSet rs = stmt.executeQuery("SELECT * FROM test_proxool")) {
            while (rs.next()) {
                System.out.println(rs.getInt("c1") + "   " + rs.getString("c2"));
            }
        }
    }
}

References

• For more information about OceanBase Connector/J, see OceanBase Connector/J.
• For more information about the Proxool connection pool, see Introduction for Users.