示例：常用操作

示例1

此示例将演示如何基于openGauss提供的JDBC接口开发应用程序。

  1. //DBtest.java
  2. //演示基于JDBC开发的主要步骤，会涉及创建数据库、创建表、插入数据等。
  4. import java.sql.Connection;
  5. import java.sql.DriverManager;
  6. import java.sql.PreparedStatement;
  7. import java.sql.SQLException;
  8. import java.sql.Statement;
  9. import java.sql.CallableStatement;
  11. public class DBTest {
  13.   //创建数据库连接。
  14.   public static Connection GetConnection(String username, String passwd) {
  15.     String driver = "org.postgresql.Driver";
  16.     String sourceURL = "jdbc:postgresql://localhost:8000/postgres";
  17.     Connection conn = null;
  18.     try {
  19.       //加载数据库驱动。
  20.       Class.forName(driver).newInstance();
  21.     } catch (Exception e) {
  22.       e.printStackTrace();
  23.       return null;
  24.     }
  26.     try {
  27.       //创建数据库连接。
  28.       conn = DriverManager.getConnection(sourceURL, username, passwd);
  29.       System.out.println("Connection succeed!");
  30.     } catch (Exception e) {
  31.       e.printStackTrace();
  32.       return null;
  33.     }
  35.     return conn;
  36.   };
  38.   //执行普通SQL语句，创建customer_t1表。
  39.   public static void CreateTable(Connection conn) {
  40.     Statement stmt = null;
  41.     try {
  42.       stmt = conn.createStatement();
  44.       //执行普通SQL语句。
  45.       int rc = stmt
  46.           .executeUpdate("CREATE TABLE customer_t1(c_customer_sk INTEGER, c_customer_name VARCHAR(32));");
  48.       stmt.close();
  49.     } catch (SQLException e) {
  50.       if (stmt != null) {
  51.         try {
  52.           stmt.close();
  53.         } catch (SQLException e1) {
  54.           e1.printStackTrace();
  55.         }
  56.       }
  57.       e.printStackTrace();
  58.     }
  59.   }
  61.   //执行预处理语句，批量插入数据。
  62.   public static void BatchInsertData(Connection conn) {
  63.     PreparedStatement pst = null;
  65.     try {
  66.       //生成预处理语句。
  67.       pst = conn.prepareStatement("INSERT INTO customer_t1 VALUES (?,?)");
  68.       for (int i = 0; i < 3; i++) {
  69.         //添加参数。
  70.         pst.setInt(1, i);
  71.         pst.setString(2, "data " + i);
  72.         pst.addBatch();
  73.       }
  74.       //执行批处理。
  75.       pst.executeBatch();
  76.       pst.close();
  77.     } catch (SQLException e) {
  78.       if (pst != null) {
  79.         try {
  80.           pst.close();
  81.         } catch (SQLException e1) {
  82.         e1.printStackTrace();
  83.         }
  84.       }
  85.       e.printStackTrace();
  86.     }
  87.   }
  89.   //执行预编译语句，更新数据。
  90.   public static void ExecPreparedSQL(Connection conn) {
  91.     PreparedStatement pstmt = null;
  92.     try {
  93.       pstmt = conn
  94.           .prepareStatement("UPDATE customer_t1 SET c_customer_name = ? WHERE c_customer_sk = 1");
  95.       pstmt.setString(1, "new Data");
  96.       int rowcount = pstmt.executeUpdate();
  97.       pstmt.close();
  98.     } catch (SQLException e) {
  99.       if (pstmt != null) {
  100.         try {
  101.           pstmt.close();
  102.         } catch (SQLException e1) {
  103.           e1.printStackTrace();
  104.         }
  105.       }
  106.       e.printStackTrace();
  107.     }
  108.   }
  111. //执行存储过程。
  112.   public static void ExecCallableSQL(Connection conn) {
  113.     CallableStatement cstmt = null;
  114.     try {
  116.       cstmt=conn.prepareCall("{? = CALL TESTPROC(?,?,?)}");
  117.       cstmt.setInt(2, 50); 
  118.       cstmt.setInt(1, 20);
  119.       cstmt.setInt(3, 90);
  120.       cstmt.registerOutParameter(4, Types.INTEGER);  //注册out类型的参数，类型为整型。
  121.       cstmt.execute();
  122.       int out = cstmt.getInt(4);  //获取out参数
  123.       System.out.println("The CallableStatment TESTPROC returns:"+out);
  124.       cstmt.close();
  125.     } catch (SQLException e) {
  126.       if (cstmt != null) {
  127.         try {
  128.           cstmt.close();
  129.         } catch (SQLException e1) {
  130.           e1.printStackTrace();
  131.         }
  132.       }
  133.       e.printStackTrace();
  134.     }
  135.   }
  138.   /**
  139.    * 主程序，逐步调用各静态方法。
  140.    * @param args
  141.   */
  142.   public static void main(String[] args) {
  143.     //创建数据库连接。
  144.     Connection conn = GetConnection("tester", "Password1234");
  146.     //创建表。
  147.     CreateTable(conn);
  149.     //批插数据。
  150.     BatchInsertData(conn);
  152.     //执行预编译语句，更新数据。
  153.     ExecPreparedSQL(conn);
  155.     //执行存储过程。
  156.     ExecCallableSQL(conn);
  158.     //关闭数据库连接。
  159.     try {
  160.       conn.close();
  161.     } catch (SQLException e) {
  162.       e.printStackTrace();
  163.     }
  165.   }
  167. }

示例2 客户端内存占用过多解决

此示例主要使用setFetchSize来调整客户端内存使用，它的原理是通过数据库游标来分批获取服务器端数据，但它会加大网络交互，可能会损失部分性能。

由于游标事务内有效，故需要先关闭自动提交，最后需要执行手动提交。

  1. // 关闭掉自动提交
  2. conn.setAutoCommit(false);
  3. Statement st = conn.createStatement();
  5. // 打开游标，每次获取50行数据
  6. st.setFetchSize(50);
  7. ResultSet rs = st.executeQuery("SELECT * FROM mytable");
  8. conn.commit();
  9. while (rs.next())
  10. {
  11.     System.out.print("a row was returned.");
  12. }
  13. rs.close();
  15. // 关闭服务器游标。
  16. st.setFetchSize(0);
  17. rs = st.executeQuery("SELECT * FROM mytable");
  18. conn.commit();
  19. while (rs.next())
  20. {
  21.     System.out.print("many rows were returned.");
  22. }
  23. rs.close();
  25. // Close the statement.
  26. st.close();
  27. conn.close();

执行完毕后可使用如下命令恢复自动提交：

  1. conn.setAutoCommit(true);