Logo Search packages:      
Sourcecode: mysql-connector-java version File versions  Download package

StatementsTest.java

/*
 Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
 

  The MySQL Connector/J is licensed under the terms of the GPLv2
  <http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most MySQL Connectors.
  There are special exceptions to the terms and conditions of the GPLv2 as it is applied to
  this software, see the FLOSS License Exception
  <http://www.mysql.com/about/legal/licensing/foss-exception.html>.

  This program is free software; you can redistribute it and/or modify it under the terms
  of the GNU General Public License as published by the Free Software Foundation; version 2
  of the License.

  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  See the GNU General Public License for more details.

  You should have received a copy of the GNU General Public License along with this
  program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth
  Floor, Boston, MA 02110-1301  USA



 */
package testsuite.simple.jdbc4;

import java.io.Reader;
import java.io.StringReader;
import java.sql.Clob;
import java.sql.Connection;
import java.sql.NClob;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

import com.mysql.jdbc.NonRegisteringDriver;

import testsuite.BaseTestCase;
import testsuite.regression.ConnectionRegressionTest.CountingReBalanceStrategy;

00044 public class StatementsTest extends BaseTestCase {

      public StatementsTest(String name) {
            super(name);
      
      }

      /**
       * Tests for ResultSet.getNCharacterStream()
       * 
       * @throws Exception
       */
00056       public void testGetNCharacterSteram() throws Exception {
          createTable("testGetNCharacterStream", "(c1 NATIONAL CHARACTER(10), c2 NATIONAL CHARACTER(10))");
          this.stmt.executeUpdate("INSERT INTO testGetNCharacterStream (c1, c2) VALUES (_utf8 'aaa', _utf8 'bbb')");
          this.rs = this.stmt.executeQuery("SELECT c1, c2 FROM testGetNCharacterStream");
          this.rs.next();
          char[] c1 = new char[3];
          this.rs.getNCharacterStream(1).read(c1);
          assertEquals("aaa", new String(c1));
          char[] c2 = new char[3];
          this.rs.getNCharacterStream("c2").read(c2);
          assertEquals("bbb", new String(c2));
          this.rs.close();
      }

      /**
       * Tests for ResultSet.getNClob()
       * 
       * @throws Exception
       */
00075       public void testGetNClob() throws Exception {
          createTable("testGetNClob", "(c1 NATIONAL CHARACTER(10), c2 NATIONAL CHARACTER(10))");
          this.stmt.executeUpdate("INSERT INTO testGetNClob (c1, c2) VALUES (_utf8 'aaa', _utf8 'bbb')");
          this.rs = this.stmt.executeQuery("SELECT c1, c2 FROM testGetNClob");
          this.rs.next();
          char[] c1 = new char[3];
          this.rs.getNClob(1).getCharacterStream().read(c1);
          assertEquals("aaa", new String(c1));
          char[] c2 = new char[3];
          this.rs.getNClob("c2").getCharacterStream().read(c2);
          assertEquals("bbb", new String(c2));
          this.rs.close();
          
          // for isBinaryEncoded = true, using PreparedStatement
          createTable("testGetNClob", "(c1 NATIONAL CHARACTER(10), c2 NATIONAL CHARACTER(10))");
          this.stmt.executeUpdate("INSERT INTO testGetNClob (c1, c2) VALUES (_utf8 'aaa', _utf8 'bbb')");
          this.pstmt = this.conn.prepareStatement("SELECT c1, c2 FROM testGetNClob");
          this.rs = this.pstmt.executeQuery();
          this.rs.next();
          c1 = new char[3];
          this.rs.getNClob(1).getCharacterStream().read(c1);
          assertEquals("aaa", new String(c1));
          c2 = new char[3];
          this.rs.getNClob("c2").getCharacterStream().read(c2);
          assertEquals("bbb", new String(c2));
          this.rs.close();
      }

      /**
       * Tests for ResultSet.getNString()
       * 
       * @throws Exception
       */
00108       public void testGetNString() throws Exception {
          createTable("testGetNString", "(c1 NATIONAL CHARACTER(10), c2 NATIONAL CHARACTER(10))");
          this.stmt.executeUpdate("INSERT INTO testGetNString (c1, c2) VALUES (_utf8 'aaa', _utf8 'bbb')");
          this.rs = this.stmt.executeQuery("SELECT c1, c2 FROM testGetNString");
          this.rs.next();
          assertEquals("aaa", this.rs.getNString(1));
          assertEquals("bbb", this.rs.getNString("c2"));
          this.rs.close();
      }

      /**
       * Tests for PreparedStatement.setNCharacterSteam()
       * 
       * @throws Exception
       */
00123       public void testSetNCharacterStream() throws Exception {
          // suppose sql_mode don't include "NO_BACKSLASH_ESCAPES"
          
          createTable("testSetNCharacterStream", "(c1 NATIONAL CHARACTER(10), c2 NATIONAL CHARACTER(10), " +
                  "c3 NATIONAL CHARACTER(10))");
          Properties props1 = new Properties();
          props1.put("useServerPrepStmts", "false"); // use client-side prepared statement
          props1.put("useUnicode", "true");
          props1.put("characterEncoding", "latin1"); // ensure charset isn't utf8 here
          Connection conn1 = getConnectionWithProps(props1);
          com.mysql.jdbc.PreparedStatement pstmt1 = (com.mysql.jdbc.PreparedStatement)
              conn1.prepareStatement("INSERT INTO testSetNCharacterStream (c1, c2, c3) VALUES (?, ?, ?)");
          pstmt1.setNCharacterStream(1, null, 0);
          pstmt1.setNCharacterStream(2, new StringReader("aaa"), 3);
          pstmt1.setNCharacterStream(3, new StringReader("\'aaa\'"), 5);
          pstmt1.execute();
          ResultSet rs1 = this.stmt.executeQuery("SELECT c1, c2, c3 FROM testSetNCharacterStream");
          rs1.next();
          assertEquals(null, rs1.getString(1));
          assertEquals("aaa", rs1.getString(2));
          assertEquals("\'aaa\'", rs1.getString(3));
          rs1.close();
          pstmt1.close();
          conn1.close();
          
          createTable("testSetNCharacterStream", "(c1 NATIONAL CHARACTER(10), c2 NATIONAL CHARACTER(10), " +
          "c3 NATIONAL CHARACTER(10))");
          Properties props2 = new Properties();
          props2.put("useServerPrepStmts", "false"); // use client-side prepared statement
          props2.put("useUnicode", "true");
          props2.put("characterEncoding", "UTF-8"); // ensure charset is utf8 here
          Connection conn2 = getConnectionWithProps(props2);
          com.mysql.jdbc.PreparedStatement pstmt2 = (com.mysql.jdbc.PreparedStatement)
              conn2.prepareStatement("INSERT INTO testSetNCharacterStream (c1, c2, c3) VALUES (?, ?, ?)");
          pstmt2.setNCharacterStream(1, null, 0);
          pstmt2.setNCharacterStream(2, new StringReader("aaa"), 3);
          pstmt2.setNCharacterStream(3, new StringReader("\'aaa\'"), 5);
          pstmt2.execute();
          ResultSet rs2 = this.stmt.executeQuery("SELECT c1, c2, c3 FROM testSetNCharacterStream");
          rs2.next();
          assertEquals(null, rs2.getString(1));
          assertEquals("aaa", rs2.getString(2));
          assertEquals("\'aaa\'", rs2.getString(3));
          rs2.close();
          pstmt2.close();
          conn2.close();
      }

      /**
       * Tests for ServerPreparedStatement.setNCharacterSteam()
       * 
       * @throws Exception
       */
00176       public void testSetNCharacterStreamServer() throws Exception {
          createTable("testSetNCharacterStreamServer", "(c1 NATIONAL CHARACTER(10))");
          Properties props1 = new Properties();
          props1.put("useServerPrepStmts", "true"); // use server-side prepared statement
          props1.put("useUnicode", "true");
          props1.put("characterEncoding", "latin1"); // ensure charset isn't utf8 here
          Connection conn1 = getConnectionWithProps(props1);
          PreparedStatement pstmt1 =  conn1.prepareStatement("INSERT INTO testSetNCharacterStreamServer (c1) VALUES (?)");
          try {
              pstmt1.setNCharacterStream(1, new StringReader("aaa"), 3);
              fail();
          } catch (SQLException e) {
              // ok
              assertEquals("Can not call setNCharacterStream() when connection character set isn't UTF-8",
                  e.getMessage());  
          }
          pstmt1.close();
          conn1.close();
          
          createTable("testSetNCharacterStreamServer", "(c1 LONGTEXT charset utf8)");
          Properties props2 = new Properties();
          props2.put("useServerPrepStmts", "true"); // use server-side prepared statement
          props2.put("useUnicode", "true");
          props2.put("characterEncoding", "UTF-8"); // ensure charset is utf8 here
          Connection conn2 = getConnectionWithProps(props2);
          PreparedStatement pstmt2 = 
              conn2.prepareStatement("INSERT INTO testSetNCharacterStreamServer (c1) VALUES (?)");
          pstmt2.setNCharacterStream(1, new StringReader(
                  new String(new char[81921])), 81921); // 10 Full Long Data Packet's chars + 1 char
          pstmt2.execute();
          ResultSet rs2 = this.stmt.executeQuery("SELECT c1 FROM testSetNCharacterStreamServer");
          rs2.next();
          assertEquals(new String(new char[81921]), rs2.getString(1));
          rs2.close();
          pstmt2.close();
          conn2.close();
      }

      /**
       * Tests for PreparedStatement.setNClob()
       * 
       * @throws Exception
       */
00219       public void testSetNClob() throws Exception {
          // suppose sql_mode don't include "NO_BACKSLASH_ESCAPES"
          
          createTable("testSetNClob", "(c1 NATIONAL CHARACTER(10), c2 NATIONAL CHARACTER(10), " +
                  "c3 NATIONAL CHARACTER(10))");
          Properties props1 = new Properties();
          props1.put("useServerPrepStmts", "false"); // use client-side prepared statement
          props1.put("useUnicode", "true");
          props1.put("characterEncoding", "latin1"); // ensure charset isn't utf8 here
          Connection conn1 = getConnectionWithProps(props1);
          PreparedStatement pstmt1 = 
              conn1.prepareStatement("INSERT INTO testSetNClob (c1, c2, c3) VALUES (?, ?, ?)");
          pstmt1.setNClob(1, (NClob)null);
          NClob nclob2 = conn1.createNClob();
          nclob2.setString(1, "aaa");
          pstmt1.setNClob(2, nclob2);                   // for setNClob(int, NClob)
          Reader reader3 = new StringReader("\'aaa\'");
          pstmt1.setNClob(3, reader3, 5);               // for setNClob(int, Reader, long)
          pstmt1.execute();
          ResultSet rs1 = this.stmt.executeQuery("SELECT c1, c2, c3 FROM testSetNClob");
          rs1.next();
          assertEquals(null, rs1.getString(1));
          assertEquals("aaa", rs1.getString(2));
          assertEquals("\'aaa\'", rs1.getString(3));
          rs1.close();
          pstmt1.close();
          conn1.close();
          
          createTable("testSetNClob", "(c1 NATIONAL CHARACTER(10), c2 NATIONAL CHARACTER(10), " +
          "c3 NATIONAL CHARACTER(10))");
          Properties props2 = new Properties();
          props2.put("useServerPrepStmts", "false"); // use client-side prepared statement
          props2.put("useUnicode", "true");
          props2.put("characterEncoding", "UTF-8"); // ensure charset is utf8 here
          Connection conn2 = getConnectionWithProps(props2);
          PreparedStatement pstmt2 = 
              conn2.prepareStatement("INSERT INTO testSetNClob (c1, c2, c3) VALUES (?, ?, ?)");
          pstmt2.setNClob(1, (NClob)null);
          nclob2 = conn2.createNClob();
          nclob2.setString(1, "aaa");
          pstmt2.setNClob(2, nclob2);             // for setNClob(int, NClob)
          reader3 = new StringReader("\'aaa\'");
          pstmt2.setNClob(3, reader3, 5);         // for setNClob(int, Reader, long)
          pstmt2.execute();
          ResultSet rs2 = this.stmt.executeQuery("SELECT c1, c2, c3 FROM testSetNClob");
          rs2.next();
          assertEquals(null, rs2.getString(1));
          assertEquals("aaa", rs2.getString(2));
          assertEquals("\'aaa\'", rs2.getString(3));
          rs2.close();
          pstmt2.close();
          conn2.close();
      }

      /**
       * Tests for ServerPreparedStatement.setNClob()
       * 
       * @throws Exception
       */
00278       public void testSetNClobServer() throws Exception {
          createTable("testSetNClobServer", "(c1 NATIONAL CHARACTER(10), c2 NATIONAL CHARACTER(10))");
          Properties props1 = new Properties();
          props1.put("useServerPrepStmts", "true"); // use server-side prepared statement
          props1.put("useUnicode", "true");
          props1.put("characterEncoding", "latin1"); // ensure charset isn't utf8 here
          Connection conn1 = getConnectionWithProps(props1);
          PreparedStatement pstmt1 = 
              conn1.prepareStatement("INSERT INTO testSetNClobServer (c1, c2) VALUES (?, ?)");
          NClob nclob1 = conn1.createNClob();
          nclob1.setString(1, "aaa");
          Reader reader2 = new StringReader("aaa");
          try {
              pstmt1.setNClob(1, nclob1);
              fail();
          } catch (SQLException e) {
              // ok
              assertEquals("Can not call setNClob() when connection character set isn't UTF-8",
                  e.getMessage());  
          }
          try {
              pstmt1.setNClob(2, reader2, 3);
              fail();
          } catch (SQLException e) {
              // ok
              assertEquals("Can not call setNClob() when connection character set isn't UTF-8",
                  e.getMessage());  
          }
          pstmt1.close();
          conn1.close();
          
          createTable("testSetNClobServer", "(c1 NATIONAL CHARACTER(10), c2 LONGTEXT charset utf8)");
          Properties props2 = new Properties();
          props2.put("useServerPrepStmts", "true"); // use server-side prepared statement
          props2.put("useUnicode", "true");
          props2.put("characterEncoding", "UTF-8"); // ensure charset is utf8 here
          Connection conn2 = getConnectionWithProps(props2);
          PreparedStatement pstmt2 = 
              conn2.prepareStatement("INSERT INTO testSetNClobServer (c1, c2) VALUES (?, ?)");
          nclob1 = conn2.createNClob();
          nclob1.setString(1, "aaa");
          pstmt2.setNClob(1, nclob1);
          pstmt2.setNClob(2, new StringReader(
                  new String(new char[81921])), 81921); // 10 Full Long Data Packet's chars + 1 char
          pstmt2.execute();
          ResultSet rs2 = this.stmt.executeQuery("SELECT c1, c2 FROM testSetNClobServer");
          rs2.next();
          assertEquals("aaa", rs2.getString(1));
          assertEquals(new String(new char[81921]), rs2.getString(2));
          rs2.close();
          pstmt2.close();
          conn2.close();
      }

      /**
       * Tests for PreparedStatement.setNString()
       * 
       * @throws Exception
       */
00337       public void testSetNString() throws Exception {
          // suppose sql_mode don't include "NO_BACKSLASH_ESCAPES"
          
          createTable("testSetNString", "(c1 NATIONAL CHARACTER(10), c2 NATIONAL CHARACTER(10), " +
                  "c3 NATIONAL CHARACTER(10)) DEFAULT CHARACTER SET cp932");
          Properties props1 = new Properties();
          props1.put("useServerPrepStmts", "false"); // use client-side prepared statement
          props1.put("useUnicode", "true");
          props1.put("characterEncoding", "MS932"); // ensure charset isn't utf8 here
          Connection conn1 = getConnectionWithProps(props1);
          PreparedStatement pstmt1 = 
              conn1.prepareStatement("INSERT INTO testSetNString (c1, c2, c3) VALUES (?, ?, ?)");
          pstmt1.setNString(1, null);
          pstmt1.setNString(2, "aaa");
          pstmt1.setNString(3, "\'aaa\'");
          pstmt1.execute();
          ResultSet rs1 = this.stmt.executeQuery("SELECT c1, c2, c3 FROM testSetNString");
          rs1.next();
          assertEquals(null, rs1.getString(1));
          assertEquals("aaa", rs1.getString(2));
          assertEquals("\'aaa\'", rs1.getString(3));
          rs1.close();
          pstmt1.close();
          conn1.close();
          
          createTable("testSetNString", "(c1 NATIONAL CHARACTER(10), c2 NATIONAL CHARACTER(10), " +
          "c3 NATIONAL CHARACTER(10)) DEFAULT CHARACTER SET cp932");
          Properties props2 = new Properties();
          props2.put("useServerPrepStmts", "false"); // use client-side prepared statement
          props2.put("useUnicode", "true");
          props2.put("characterEncoding", "UTF-8"); // ensure charset is utf8 here
          Connection conn2 = getConnectionWithProps(props2);
          PreparedStatement pstmt2 = 
              conn2.prepareStatement("INSERT INTO testSetNString (c1, c2, c3) VALUES (?, ?, ?)");
          pstmt2.setNString(1, null);
          pstmt2.setNString(2, "aaa");
          pstmt2.setNString(3, "\'aaa\'");
          pstmt2.execute();
          ResultSet rs2 = this.stmt.executeQuery("SELECT c1, c2, c3 FROM testSetNString");
          rs2.next();
          assertEquals(null, rs2.getString(1));
          assertEquals("aaa", rs2.getString(2));
          assertEquals("\'aaa\'", rs2.getString(3));
          rs2.close();
          pstmt2.close();
          conn2.close();
      }

      /**
       * Tests for ServerPreparedStatement.setNString()
       * 
       * @throws Exception
       */
00390       public void testSetNStringServer() throws Exception {
          createTable("testSetNStringServer", "(c1 NATIONAL CHARACTER(10))");
          Properties props1 = new Properties();
          props1.put("useServerPrepStmts", "true"); // use server-side prepared statement
          props1.put("useUnicode", "true");
          props1.put("characterEncoding", "latin1"); // ensure charset isn't utf8 here
          Connection conn1 = getConnectionWithProps(props1);
          PreparedStatement pstmt1 = 
              conn1.prepareStatement("INSERT INTO testSetNStringServer (c1) VALUES (?)");
          try {
              pstmt1.setNString(1, "aaa");
              fail();
          } catch (SQLException e) {
              // ok
              assertEquals("Can not call setNString() when connection character set isn't UTF-8",
                  e.getMessage());  
          }
          pstmt1.close();
          conn1.close();
          
          createTable("testSetNStringServer", "(c1 NATIONAL CHARACTER(10))");
          Properties props2 = new Properties();
          props2.put("useServerPrepStmts", "true"); // use server-side prepared statement
          props2.put("useUnicode", "true");
          props2.put("characterEncoding", "UTF-8"); // ensure charset is utf8 here
          Connection conn2 = getConnectionWithProps(props2);
          PreparedStatement pstmt2 = 
              conn2.prepareStatement("INSERT INTO testSetNStringServer (c1) VALUES (?)");
          pstmt2.setNString(1, "\'aaa\'");
          pstmt2.execute();
          ResultSet rs2 = this.stmt.executeQuery("SELECT c1 FROM testSetNStringServer");
          rs2.next();
          assertEquals("\'aaa\'", rs2.getString(1));
          rs2.close();
          pstmt2.close();
          conn2.close();
      }

      /**
       * Tests for ResultSet.updateNCharacterStream()
       * 
       * @throws Exception
       */
00433       public void testUpdateNCharacterStream() throws Exception {
          createTable("testUpdateNCharacterStream", 
                  "(c1 CHAR(10) PRIMARY KEY, c2 NATIONAL CHARACTER(10)) default character set sjis");
          Properties props1 = new Properties();
          props1.put("useServerPrepStmts", "true"); // use server-side prepared statement
          props1.put("characterEncoding", "UTF-8"); // ensure charset isn't utf8 here
          Connection conn1 = getConnectionWithProps(props1);
          PreparedStatement pstmt1 = conn1.prepareStatement(
                  "INSERT INTO testUpdateNCharacterStream (c1, c2) VALUES (?, ?)");
          pstmt1.setString(1, "1");
          pstmt1.setNCharacterStream(2, new StringReader("aaa"), 3);
          pstmt1.execute();
          Statement stmt1 = conn1.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
          ResultSet rs1 = stmt1.executeQuery("SELECT c1, c2 FROM testUpdateNCharacterStream");
          rs1.next();
          rs1.updateNCharacterStream("c2", new StringReader("bbb"), 3);
          rs1.updateRow();
          rs1.moveToInsertRow();
          rs1.updateString("c1", "2");
          rs1.updateNCharacterStream("c2", new StringReader("ccc"), 3);
          rs1.insertRow();
          ResultSet rs2 = stmt1.executeQuery("SELECT c1, c2 FROM testUpdateNCharacterStream");
          rs2.next();
          assertEquals("1", rs2.getString("c1"));
          assertEquals("bbb", rs2.getNString("c2"));
          rs2.next();
          assertEquals("2", rs2.getString("c1"));
          assertEquals("ccc", rs2.getNString("c2"));
          pstmt1.close();
          stmt1.close();
          conn1.close();
          
          createTable("testUpdateNCharacterStream", 
                  "(c1 CHAR(10) PRIMARY KEY, c2 CHAR(10)) default character set sjis"); // sjis field
          Properties props2 = new Properties();
          props2.put("useServerPrepStmts", "true"); // use server-side prepared statement
          props2.put("characterEncoding", "SJIS"); // ensure charset isn't utf8 here
          Connection conn2 = getConnectionWithProps(props2);
          PreparedStatement pstmt2 = conn2.prepareStatement(
                  "INSERT INTO testUpdateNCharacterStream (c1, c2) VALUES (?, ?)");
          pstmt2.setString(1, "1");
          pstmt2.setString(2, "aaa");
          pstmt2.execute();
          Statement stmt2 = conn2.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
          ResultSet rs3 = stmt2.executeQuery("SELECT c1, c2 FROM testUpdateNCharacterStream");
          rs3.next();
          try {
              rs3.updateNCharacterStream("c2", new StringReader("bbb"), 3); // field's charset isn't utf8
              fail();
          } catch (SQLException ex) {
              assertEquals("Can not call updateNCharacterStream() when field's character set isn't UTF-8",
                      ex.getMessage());
          }
          rs3.close();
          pstmt2.close();
          stmt2.close();
          conn2.close();  
      }

      /**
       * Tests for ResultSet.updateNClob()
       * 
       * @throws Exception
       */
00497       public void testUpdateNClob() throws Exception {
          createTable("testUpdateNChlob", 
                  "(c1 CHAR(10) PRIMARY KEY, c2 NATIONAL CHARACTER(10)) default character set sjis");
          Properties props1 = new Properties();
          props1.put("useServerPrepStmts", "true"); // use server-side prepared statement
          props1.put("characterEncoding", "UTF-8"); // ensure charset isn't utf8 here
          Connection conn1 = getConnectionWithProps(props1);
          PreparedStatement pstmt1 = conn1.prepareStatement(
                  "INSERT INTO testUpdateNChlob (c1, c2) VALUES (?, ?)");
          pstmt1.setString(1, "1");
          NClob nClob1 = conn1.createNClob();
          nClob1.setString(1, "aaa");
          pstmt1.setNClob(2, nClob1);
          pstmt1.execute();
          Statement stmt1 = conn1.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
          ResultSet rs1 = stmt1.executeQuery("SELECT c1, c2 FROM testUpdateNChlob");
          rs1.next();
          NClob nClob2 = conn1.createNClob();
          nClob2.setString(1, "bbb");
          rs1.updateNClob("c2", nClob2);
          rs1.updateRow();
          rs1.moveToInsertRow();
          rs1.updateString("c1", "2");
          NClob nClob3 = conn1.createNClob();
          nClob3.setString(1, "ccc");
          rs1.updateNClob("c2", nClob3);
          rs1.insertRow();
          ResultSet rs2 = stmt1.executeQuery("SELECT c1, c2 FROM testUpdateNChlob");
          rs2.next();
          assertEquals("1", rs2.getString("c1"));
          assertEquals("bbb", rs2.getNString("c2"));
          rs2.next();
          assertEquals("2", rs2.getString("c1"));
          assertEquals("ccc", rs2.getNString("c2"));
          pstmt1.close();
          stmt1.close();
          conn1.close();
          
          createTable("testUpdateNChlob", 
                  "(c1 CHAR(10) PRIMARY KEY, c2 CHAR(10)) default character set sjis"); // sjis field
          Properties props2 = new Properties();
          props2.put("useServerPrepStmts", "true"); // use server-side prepared statement
          props2.put("characterEncoding", "SJIS"); // ensure charset isn't utf8 here
          Connection conn2 = getConnectionWithProps(props2);
          PreparedStatement pstmt2 = conn2.prepareStatement(
                  "INSERT INTO testUpdateNChlob (c1, c2) VALUES (?, ?)");
          pstmt2.setString(1, "1");
          pstmt2.setString(2, "aaa");
          pstmt2.execute();
          Statement stmt2 = conn2.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
          ResultSet rs3 = stmt2.executeQuery("SELECT c1, c2 FROM testUpdateNChlob");
          rs3.next();
          NClob nClob4 = conn2.createNClob();
          nClob4.setString(1, "bbb");
          try {
              rs3.updateNClob("c2", nClob4); // field's charset isn't utf8
              fail();
          } catch (SQLException ex) {
              assertEquals("Can not call updateNClob() when field's character set isn't UTF-8",
                      ex.getMessage());
          }
          rs3.close();
          pstmt2.close();
          stmt2.close();
          conn2.close();  
      }

      /**
       * Tests for ResultSet.updateNString()
       * 
       * @throws Exception
       */
00569       public void testUpdateNString() throws Exception {
          createTable("testUpdateNString", 
                  "(c1 CHAR(10) PRIMARY KEY, c2 NATIONAL CHARACTER(10)) default character set sjis");
          Properties props1 = new Properties();
          props1.put("useServerPrepStmts", "true"); // use server-side prepared statement
          props1.put("characterEncoding", "UTF-8"); // ensure charset is utf8 here
          Connection conn1 = getConnectionWithProps(props1);
          PreparedStatement pstmt1 = conn1.prepareStatement(
                  "INSERT INTO testUpdateNString (c1, c2) VALUES (?, ?)");
          pstmt1.setString(1, "1");
          pstmt1.setNString(2, "aaa");
          pstmt1.execute();
          Statement stmt1 = conn1.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
          ResultSet rs1 = stmt1.executeQuery("SELECT c1, c2 FROM testUpdateNString");
          rs1.next();
          rs1.updateNString("c2", "bbb");
          rs1.updateRow();
          rs1.moveToInsertRow();
          rs1.updateString("c1", "2");
          rs1.updateNString("c2", "ccc");
          rs1.insertRow();
          ResultSet rs2 = stmt1.executeQuery("SELECT c1, c2 FROM testUpdateNString");
          rs2.next();
          assertEquals("1", rs2.getString("c1"));
          assertEquals("bbb", rs2.getNString("c2"));
          rs2.next();
          assertEquals("2", rs2.getString("c1"));
          assertEquals("ccc", rs2.getNString("c2"));
          pstmt1.close();
          stmt1.close();
          conn1.close();
          
          createTable("testUpdateNString", 
                  "(c1 CHAR(10) PRIMARY KEY, c2 CHAR(10)) default character set sjis"); // sjis field
          Properties props2 = new Properties();
          props2.put("useServerPrepStmts", "true"); // use server-side prepared statement
          props2.put("characterEncoding", "SJIS"); // ensure charset isn't utf8 here
          Connection conn2 = getConnectionWithProps(props2);
          PreparedStatement pstmt2 = conn2.prepareStatement(
                  "INSERT INTO testUpdateNString (c1, c2) VALUES (?, ?)");
          pstmt2.setString(1, "1");
          pstmt2.setString(2, "aaa");
          pstmt2.execute();
          Statement stmt2 = conn2.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
          ResultSet rs3 = stmt2.executeQuery("SELECT c1, c2 FROM testUpdateNString");
          rs3.next();
          try {
              rs3.updateNString("c2", "bbb"); // field's charset isn't utf8
              fail();
          } catch (SQLException ex) {
              assertEquals("Can not call updateNString() when field's character set isn't UTF-8",
                      ex.getMessage());
          }
          rs3.close();
          pstmt2.close();
          stmt2.close();
          conn2.close();      
      }
      
      public void testJdbc4LoadBalancing() throws Exception {
            Properties props = new Properties();
            props.setProperty("loadBalanceStrategy", CountingReBalanceStrategy.class.getName());
            props.setProperty("loadBalanceAutoCommitStatementThreshold", "3");
            
            String portNumber = new NonRegisteringDriver().parseURL(dbUrl, null).getProperty(NonRegisteringDriver.PORT_PROPERTY_KEY);
            
            if (portNumber == null) {
                  portNumber = "3306";
            }
            
            Connection conn2 = this.getUnreliableLoadBalancedConnection(new String[]{"first", "second"}, props);
            try{
                  conn2.createNClob();
            } catch (SQLException e){
                  fail("Unable to call Connection.createNClob() in load-balanced connection");
            }
            
      }

}

Generated by  Doxygen 1.6.0   Back to index