resultsetregressiontest.java

开发MySql数据库的最新JDBC驱动。

			this.rs.moveToInsertRow();

			clob.setString(1, "baz");
			this.rs.updateInt(1, 2);
			this.rs.updateClob(2, clob);
			this.rs.insertRow();

			clob.setString(1, "bat");
			this.rs.updateInt(1, 3);
			this.rs.updateClob(2, clob);
			this.rs.insertRow();

			this.rs.close();

			this.rs = this.stmt
					.executeQuery("SELECT intField, clobField FROM testUpdateClob ORDER BY intField");

			this.rs.next();
			assertTrue((this.rs.getInt(1) == 1)
					&& this.rs.getString(2).equals("bar"));

			this.rs.next();
			assertTrue((this.rs.getInt(1) == 2)
					&& this.rs.getString(2).equals("baz"));

			this.rs.next();
			assertTrue((this.rs.getInt(1) == 3)
					&& this.rs.getString(2).equals("bat"));
		} finally {
			this.stmt.executeUpdate("DROP TABLE IF EXISTS testUpdateClob");
		}
	}

	/**
	 * Tests fix for BUG#4482, ResultSet.getObject() returns wrong type for
	 * strings when using prepared statements.
	 * 
	 * @throws Exception
	 *             if the test fails.
	 */
	public void testBug4482() throws Exception {
		this.rs = this.conn.prepareStatement("SELECT 'abcdef'").executeQuery();
		assertTrue(this.rs.next());
		assertTrue(this.rs.getObject(1) instanceof String);
	}

	/**
	 * Test fix for BUG#4689 - WasNull not getting set correctly for binary
	 * result sets.
	 */
	public void testBug4689() throws Exception {
		try {
			this.stmt.executeUpdate("DROP TABLE IF EXISTS testBug4689");
			this.stmt
					.executeUpdate("CREATE TABLE testBug4689 (tinyintField tinyint, tinyintFieldNull tinyint, "
							+ "intField int, intFieldNull int, "
							+ "bigintField bigint, bigintFieldNull bigint, "
							+ "shortField smallint, shortFieldNull smallint, "
							+ "doubleField double, doubleFieldNull double)");

			this.stmt.executeUpdate("INSERT INTO testBug4689 VALUES (1, null, "
					+ "1, null, " + "1, null, " + "1, null, " + "1, null)");

			PreparedStatement pStmt = this.conn
					.prepareStatement("SELECT tinyintField, tinyintFieldNull,"
							+ "intField, intFieldNull, "
							+ "bigintField, bigintFieldNull, "
							+ "shortField, shortFieldNull, "
							+ "doubleField, doubleFieldNull FROM testBug4689");
			this.rs = pStmt.executeQuery();
			assertTrue(this.rs.next());

			assertTrue(this.rs.getByte(1) == 1);
			assertTrue(this.rs.wasNull() == false);
			assertTrue(this.rs.getByte(2) == 0);
			assertTrue(this.rs.wasNull() == true);

			assertTrue(this.rs.getInt(3) == 1);
			assertTrue(this.rs.wasNull() == false);
			assertTrue(this.rs.getInt(4) == 0);
			assertTrue(this.rs.wasNull() == true);

			assertTrue(this.rs.getInt(5) == 1);
			assertTrue(this.rs.wasNull() == false);
			assertTrue(this.rs.getInt(6) == 0);
			assertTrue(this.rs.wasNull() == true);

			assertTrue(this.rs.getShort(7) == 1);
			assertTrue(this.rs.wasNull() == false);
			assertTrue(this.rs.getShort(8) == 0);
			assertTrue(this.rs.wasNull() == true);

			assertTrue(this.rs.getDouble(9) == 1);
			assertTrue(this.rs.wasNull() == false);
			assertTrue(this.rs.getDouble(10) == 0);
			assertTrue(this.rs.wasNull() == true);
		} finally {
			this.stmt.executeUpdate("DROP TABLE IF EXISTS testBug4689");
		}
	}

	/**
	 * Tests fix for BUG#5032 -- ResultSet.getObject() doesn't return type
	 * Boolean for pseudo-bit types from prepared statements on 4.1.x.
	 * 
	 * @throws Exception
	 *             if the test fails.
	 */
	public void testBug5032() throws Exception {
		if (versionMeetsMinimum(4, 1)) {
			PreparedStatement pStmt = null;

			try {
				this.stmt.executeUpdate("DROP TABLE IF EXISTS testBug5032");
				this.stmt.executeUpdate("CREATE TABLE testBug5032(field1 BIT)");
				this.stmt.executeUpdate("INSERT INTO testBug5032 VALUES (1)");

				pStmt = this.conn
						.prepareStatement("SELECT field1 FROM testBug5032");
				this.rs = pStmt.executeQuery();
				assertTrue(this.rs.next());
				assertTrue(this.rs.getObject(1) instanceof Boolean);
			} finally {
				this.stmt.executeUpdate("DROP TABLE IF EXISTS testBug5032");

				if (pStmt != null) {
					pStmt.close();
				}
			}
		}
	}

	/**
	 * Tests fix for BUG#5069 -- ResultSet.getMetaData() should not return
	 * incorrectly-initialized metadata if the result set has been closed, but
	 * should instead throw a SQLException. Also tests fix for getRow() and
	 * getWarnings() and traversal methods.
	 * 
	 * @throws Exception
	 *             if the test fails.
	 */
	public void testBug5069() throws Exception {
		try {
			this.rs = this.stmt.executeQuery("SELECT 1");
			this.rs.close();

			try {
				ResultSetMetaData md = this.rs.getMetaData();
			} catch (NullPointerException npEx) {
				fail("Should not catch NullPointerException here");
			} catch (SQLException sqlEx) {
				assertTrue(SQLError.SQL_STATE_GENERAL_ERROR.equals(sqlEx
						.getSQLState()));
			}

			try {
				this.rs.getRow();
			} catch (NullPointerException npEx) {
				fail("Should not catch NullPointerException here");
			} catch (SQLException sqlEx) {
				assertTrue(SQLError.SQL_STATE_GENERAL_ERROR.equals(sqlEx
						.getSQLState()));
			}

			try {
				this.rs.getWarnings();
			} catch (NullPointerException npEx) {
				fail("Should not catch NullPointerException here");
			} catch (SQLException sqlEx) {
				assertTrue(SQLError.SQL_STATE_GENERAL_ERROR.equals(sqlEx
						.getSQLState()));
			}

			try {
				this.rs.first();
			} catch (NullPointerException npEx) {
				fail("Should not catch NullPointerException here");
			} catch (SQLException sqlEx) {
				assertTrue(SQLError.SQL_STATE_GENERAL_ERROR.equals(sqlEx
						.getSQLState()));
			}

			try {
				this.rs.beforeFirst();
			} catch (NullPointerException npEx) {
				fail("Should not catch NullPointerException here");
			} catch (SQLException sqlEx) {
				assertTrue(SQLError.SQL_STATE_GENERAL_ERROR.equals(sqlEx
						.getSQLState()));
			}

			try {
				this.rs.last();
			} catch (NullPointerException npEx) {
				fail("Should not catch NullPointerException here");
			} catch (SQLException sqlEx) {
				assertTrue(SQLError.SQL_STATE_GENERAL_ERROR.equals(sqlEx
						.getSQLState()));
			}

			try {
				this.rs.afterLast();
			} catch (NullPointerException npEx) {
				fail("Should not catch NullPointerException here");
			} catch (SQLException sqlEx) {
				assertTrue(SQLError.SQL_STATE_GENERAL_ERROR.equals(sqlEx
						.getSQLState()));
			}

			try {
				this.rs.relative(0);
			} catch (NullPointerException npEx) {
				fail("Should not catch NullPointerException here");
			} catch (SQLException sqlEx) {
				assertTrue(SQLError.SQL_STATE_GENERAL_ERROR.equals(sqlEx
						.getSQLState()));
			}

			try {
				this.rs.next();
			} catch (NullPointerException npEx) {
				fail("Should not catch NullPointerException here");
			} catch (SQLException sqlEx) {
				assertTrue(SQLError.SQL_STATE_GENERAL_ERROR.equals(sqlEx
						.getSQLState()));
			}

			try {
				this.rs.previous();
			} catch (NullPointerException npEx) {
				fail("Should not catch NullPointerException here");
			} catch (SQLException sqlEx) {
				assertTrue(SQLError.SQL_STATE_GENERAL_ERROR.equals(sqlEx
						.getSQLState()));
			}

			try {
				this.rs.isBeforeFirst();
			} catch (NullPointerException npEx) {
				fail("Should not catch NullPointerException here");
			} catch (SQLException sqlEx) {
				assertTrue(SQLError.SQL_STATE_GENERAL_ERROR.equals(sqlEx
						.getSQLState()));
			}

			try {
				this.rs.isFirst();
			} catch (NullPointerException npEx) {
				fail("Should not catch NullPointerException here");
			} catch (SQLException sqlEx) {
				assertTrue(SQLError.SQL_STATE_GENERAL_ERROR.equals(sqlEx
						.getSQLState()));
			}

			try {
				this.rs.isAfterLast();
			} catch (NullPointerException npEx) {
				fail("Should not catch NullPointerException here");
			} catch (SQLException sqlEx) {
				assertTrue(SQLError.SQL_STATE_GENERAL_ERROR.equals(sqlEx
						.getSQLState()));
			}

			try {
				this.rs.isLast();
			} catch (NullPointerException npEx) {
				fail("Should not catch NullPointerException here");
			} catch (SQLException sqlEx) {
				assertTrue(SQLError.SQL_STATE_GENERAL_ERROR.equals(sqlEx
						.getSQLState()));
			}
		} finally {
			if (this.rs != null) {
				this.rs.close();
				this.rs = null;
			}
		}
	}

	/**
	 * Tests for BUG#5235, ClassCastException on all-zero date field when
	 * zeroDatetimeBehavior is 'convertToNull'...however it appears that this
	 * bug doesn't exist. This is a placeholder until we get more data from the
	 * user on how they provoke this bug to happen.
	 * 
	 * @throws Exception
	 *             if the test fails.
	 */
	public void testBug5235() throws Exception {
		try {
			this.stmt.executeUpdate("DROP TABLE IF EXISTS testBug5235");
			this.stmt.executeUpdate("CREATE TABLE testBug5235(field1 DATE)");
			this.stmt
					.executeUpdate("INSERT INTO testBug5235 (field1) VALUES ('0000-00-00')");

			Properties props = new Properties();
			props.setProperty("zeroDateTimeBehavior", "convertToNull");

			Connection nullConn = getConnectionWithProps(props);

			this.rs = nullConn.createStatement().executeQuery(
					"SELECT field1 FROM testBug5235");
			this.rs.next();
			assertTrue(null == this.rs.getObject(1));
		} finally {
			this.stmt.executeUpdate("DROP TABLE IF EXISTS testBug5235");
		}
	}

	/**
	 * Tests for BUG#5136, GEOMETRY types getting corrupted, turns out to be a
	 * server bug.
	 * 
	 * @throws Exception
	 *             if the test fails.
	 */
	public void testBug5136() throws Exception {
		if (false) {
			PreparedStatement toGeom = this.conn
					.prepareStatement("select GeomFromText(?)");
			PreparedStatement toText = this.conn
					.prepareStatement("select AsText(?)");

			String inText = "POINT(146.67596278 -36.54368233)";

			// First assert that the problem is not at the server end
			this.rs = this.stmt.executeQuery("select AsText(GeomFromText('"
					+ inText + "'))");
			this.rs.next();

			String outText = this.rs.getString(1);
			this.rs.close();
			assertTrue(
					"Server side only\n In: " + inText + "\nOut: " + outText,
					inText.equals(outText));

			// Now bring a binary geometry object to the client and send it back
			toGeom.setString(1, inText);
			this.rs = toGeom.executeQuery();
			this.rs.next();

			// Return a binary geometry object from the WKT
			Object geom = this.rs.getObject(1);
			this.rs.close();
			toText.setObject(1, geom);
			this.rs = toText.executeQuery();
			this.rs.next();

			// Return WKT from the binary geometry
			outText = this.rs.getString(1);
			this.rs.close();
			assertTrue("Server to client and back\n In: " + inText + "\nOut: "
					+ outText, inText.equals(outText));
		}
	}

	/**
	 * Tests fix for BUG#5664, ResultSet.updateByte() when on insert row throws
	 * ArrayOutOfBoundsException.
	 * 
	 * @throws Exception
	 *             if the test fails.
	 */
	public void testBug5664() throws Exception {
		try {
			this.stmt.executeUpdate("DROP TABLE IF EXISTS testBug5664");
			this.stmt
					.executeUpdate("CREATE TABLE testBug5664 (pkfield int PRIMARY KEY NOT NULL, field1 SMALLINT)");
			this.stmt.executeUpdate("INSERT INTO testBug5664 VALUES (1, 1)");

			Statement updatableStmt = this.conn
					.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
							ResultSet.CONCUR_UPDATABLE);

			this.rs = updatableStmt
					.executeQuery("SELECT pkfield, field1 FROM testBug5664");
			this.rs.next();
			this.rs.moveToInsertRow();
			this.rs.updateInt(1, 2);
			this.rs.updateByte(2, (byte) 2);
		} finally {
			this.stmt.executeUpdate("DROP TABLE IF EXISTS testBug5664");
		}
	}

	public void testBogusTimestampAsString() throws Exception {

		this.rs = this.stmt.executeQuery("SELECT '2004-08-13 13:21:17.'");

		this.rs.next();

		// We're only checking for an exception being thrown here as the bug
		this.rs.getTimestamp(1);

	}

	/**
	 * Tests our ability to reject NaN and +/- INF in
	 * PreparedStatement.setDouble();
	 */
	public void testBug5717() throws Exception {
		try {
			this.stmt.executeUpdate("DROP TABLE IF EXISTS testBug5717");
			this.stmt.executeUpdate("CREATE TABLE testBug5717 (field1 DOUBLE)");
			this.pstmt = this.conn
					.prepareStatement("INSERT INTO testBug5717 VALUES (?)");

			try {
				this.pstmt.setDouble(1, Double.NEGATIVE_INFINITY);
				fail("Exception should've been thrown");
			} catch (Exception ex) {
				// expected
			}

			try {
				this.pstmt.setDouble(1, Double.POSITIVE_INFINITY);
				fail("Exception should've been thrown");
			} catch (Exception ex) {
				// expected
			}

			try {
				this.pstmt.setDouble(1, Double.NaN);
				fail("Exception should've been thrown");
			} catch (Exception ex) {
				// expected
			}
		} finally {
			if (this.pstmt != null) {
				this.pstmt.close();
			}

			this.stmt.executeUpdate("DROP TABLE IF EXISTS testBug5717");
		}
	}

	/**
	 * Tests fix for server issue that drops precision on aggregate operations
	 * on DECIMAL types, because they come back as DOUBLEs.
	 *