Java Statement.setFetchSize方法代码示例

import java.sql.Statement; //导入方法依赖的package包/类
@Test
public void testCursor() throws SQLException {

  con.setAutoCommit(false);

  Statement ps = con.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);

  ps.setFetchSize(3);

  ResultSet rs = ps.executeQuery("SELECT * FROM Fortune");
  int count = 0;
  while (rs.next()) {
    count++;
  }
  System.out.println("got result " + count);

}
 

import java.sql.Statement; //导入方法依赖的package包/类
public void testCompression() throws Exception {
    Connection compressedConn = getConnectionWithProps("useCompression=true,maxAllowedPacket=33554432");
    Statement compressedStmt = compressedConn.createStatement();
    compressedStmt.setFetchSize(Integer.MIN_VALUE);
    this.rs = compressedStmt.executeQuery("select repeat('a', 256 * 256 * 256 - 5)");
    this.rs.next();
    String str = this.rs.getString(1);

    assertEquals((256 * 256 * 256 - 5), str.length());

    for (int i = 0; i < str.length(); i++) {
        if (str.charAt(i) != 'a') {
            fail();
        }
    }
}
 

import java.sql.Statement; //导入方法依赖的package包/类
public void testBug35170() throws Exception {
    Statement stt = null;

    try {
        stt = this.conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
        stt.setFetchSize(Integer.MIN_VALUE);
        this.rs = stt.executeQuery("select 1");
        this.rs.next();
        while (!this.rs.isAfterLast()) {
            this.rs.getString(1);
            this.rs.next();
        }
    } finally {
        if (stt != null) {
            stt.close();
        }
    }

}
 

import java.sql.Statement; //导入方法依赖的package包/类
public void testBug31193() throws Exception {
    createTable("bug31193", "(sometime datetime, junk text)");
    Connection fetchConn = getConnectionWithProps("useCursorFetch=true");
    Statement fetchStmt = fetchConn.createStatement();

    fetchStmt.setFetchSize(10000);

    assertEquals(1, fetchStmt.executeUpdate("INSERT INTO bug31193 (sometime) values ('2007-01-01 12:34:56.7')"));
    this.rs = fetchStmt.executeQuery("SELECT * FROM bug31193");
    this.rs.next();
    String badDatetime = this.rs.getString("sometime");

    this.rs = fetchStmt.executeQuery("SELECT sometime FROM bug31193");
    this.rs.next();
    String goodDatetime = this.rs.getString("sometime");
    assertEquals(goodDatetime, badDatetime);
}
 

import java.sql.Statement; //导入方法依赖的package包/类
@Override
public EntityCursor readAll(String entityType) throws SQLException {
  checkAndInitConnection();
  EntityCursor entityCursor = null;
  if (entityType != null) {
    List<String> columns = getColumns(entityType);
    Statement statement = getConnection(entityType).createStatement();
    statement.setFetchSize(20);
    ResultSet
        resultSet =
        statement.executeQuery("SELECT * FROM `" + entityType + CharacterConstants.ACUTE);
    entityCursor =
        new EntityCursor(statement, resultSet, columns, getPrimaryKey(entityType), entityType);
  }
  return entityCursor;
}
 

import java.sql.Statement; //导入方法依赖的package包/类
/**
 * Tests that streaming result sets are registered correctly.
 * 
 * @throws Exception
 *             if any errors occur
 */
public void testClobberStreamingRS() throws Exception {
    try {
        Properties props = new Properties();
        props.setProperty("clobberStreamingResults", "true");

        Connection clobberConn = getConnectionWithProps(props);

        Statement clobberStmt = clobberConn.createStatement();

        clobberStmt.executeUpdate("DROP TABLE IF EXISTS StreamingClobber");
        clobberStmt.executeUpdate("CREATE TABLE StreamingClobber ( DUMMYID INTEGER NOT NULL, DUMMYNAME VARCHAR(32),PRIMARY KEY (DUMMYID) )");
        clobberStmt.executeUpdate("INSERT INTO StreamingClobber (DUMMYID, DUMMYNAME) VALUES (0, NULL)");
        clobberStmt.executeUpdate("INSERT INTO StreamingClobber (DUMMYID, DUMMYNAME) VALUES (1, 'nro 1')");
        clobberStmt.executeUpdate("INSERT INTO StreamingClobber (DUMMYID, DUMMYNAME) VALUES (2, 'nro 2')");
        clobberStmt.executeUpdate("INSERT INTO StreamingClobber (DUMMYID, DUMMYNAME) VALUES (3, 'nro 3')");

        Statement streamStmt = null;

        try {
            streamStmt = clobberConn.createStatement(java.sql.ResultSet.TYPE_FORWARD_ONLY, java.sql.ResultSet.CONCUR_READ_ONLY);
            streamStmt.setFetchSize(Integer.MIN_VALUE);

            this.rs = streamStmt.executeQuery("SELECT DUMMYID, DUMMYNAME FROM StreamingClobber ORDER BY DUMMYID");

            this.rs.next();

            // This should proceed normally, after the driver clears the input stream
            ResultSet rs2 = clobberStmt.executeQuery("SHOW VARIABLES");
            rs2.next();
            this.rs.close();
        } finally {
            if (streamStmt != null) {
                streamStmt.close();
            }
        }
    } finally {
        this.stmt.executeUpdate("DROP TABLE IF EXISTS StreamingClobber");
    }
}
 

import java.sql.Statement; //导入方法依赖的package包/类
/**
 * Tests fix for BUG#26173 - fetching rows via cursor retrieves corrupted
 * data.
 * 
 * @throws Exception
 *             if the test fails.
 */
public void testBug26173() throws Exception {
    if (!versionMeetsMinimum(5, 0)) {
        return;
    }

    createTable("testBug26173", "(fkey int, fdate date, fprice decimal(15, 2), fdiscount decimal(5,3))", "InnoDB");
    this.stmt.executeUpdate("insert into testBug26173 values (1, '2007-02-23', 99.9, 0.02)");

    Connection fetchConn = null;
    Statement stmtRead = null;

    Properties props = new Properties();
    props.setProperty("useServerPrepStmts", "true");
    props.setProperty("useCursorFetch", "true");

    try {

        fetchConn = getConnectionWithProps(props);
        stmtRead = fetchConn.createStatement();
        stmtRead.setFetchSize(1000);

        this.rs = stmtRead.executeQuery("select extract(year from fdate) as fyear, fprice * (1 - fdiscount) as fvalue from testBug26173");

        assertTrue(this.rs.next());
        assertEquals(2007, this.rs.getInt(1));
        assertEquals("97.90200", this.rs.getString(2));
    } finally {
        if (stmtRead != null) {
            stmtRead.close();
        }

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

import java.sql.Statement; //导入方法依赖的package包/类
/**
 * Tests fix for Bug#33678 - Multiple result sets not supported in
 * "streaming" mode. This fix covers both normal statements, and stored
 * procedures, with the exception of stored procedures with registered
 * OUTPUT parameters, which can't be used at all with "streaming" result
 * sets.
 * 
 * @throws Exception
 */
public void testBug33678() throws Exception {
    if (!versionMeetsMinimum(4, 1)) {
        return;
    }

    createTable("testBug33678", "(field1 INT)");

    Connection multiConn = getConnectionWithProps("allowMultiQueries=true");
    Statement multiStmt = multiConn.createStatement();

    try {
        multiStmt.setFetchSize(Integer.MIN_VALUE);

        multiStmt.execute("SELECT 1 UNION SELECT 2; INSERT INTO testBug33678 VALUES (1); UPDATE testBug33678 set field1=2; "
                + "INSERT INTO testBug33678 VALUES(3); UPDATE testBug33678 set field1=2 WHERE field1=3; UPDATE testBug33678 set field1=2; SELECT 1");
        this.rs = multiStmt.getResultSet();
        this.rs.next();
        assertEquals("1", this.rs.getString(1));

        assertFalse(multiStmt.getMoreResults());
        assertEquals(1, multiStmt.getUpdateCount());
        assertFalse(multiStmt.getMoreResults());
        assertEquals(1, multiStmt.getUpdateCount());
        assertFalse(multiStmt.getMoreResults());
        assertEquals(1, multiStmt.getUpdateCount());
        assertFalse(multiStmt.getMoreResults());
        assertEquals(1, multiStmt.getUpdateCount());
        assertFalse(multiStmt.getMoreResults());
        assertEquals(2, multiStmt.getUpdateCount());
        assertTrue(multiStmt.getMoreResults());
        this.rs = multiStmt.getResultSet();
        this.rs.next();
        assertEquals("1", this.rs.getString(1));

        this.rs.close();

        multiStmt.execute("INSERT INTO testBug33678 VALUES (1); INSERT INTO testBug33678 VALUES (1), (2); INSERT INTO testBug33678 VALUES (1), (2), (3)");

        assertEquals(1, multiStmt.getUpdateCount());
        assertFalse(multiStmt.getMoreResults());
        assertEquals(2, multiStmt.getUpdateCount());
        assertFalse(multiStmt.getMoreResults());
        assertEquals(3, multiStmt.getUpdateCount());
        assertFalse(multiStmt.getMoreResults() && multiStmt.getUpdateCount() == -1);

        this.rs.close();

        if (versionMeetsMinimum(5, 0)) {
            createProcedure("spBug33678", "() BEGIN SELECT 1; SELECT 2; SELECT 3; END");

            CallableStatement cStmt = multiConn.prepareCall("{CALL spBug33678()}");
            cStmt.setFetchSize(Integer.MIN_VALUE);
            cStmt.execute();

            for (int i = 0; i < 2; i++) {
                if (i != 0) {
                    assertTrue(cStmt.getMoreResults());
                }

                this.rs = cStmt.getResultSet();
                assertTrue(this.rs.next());
                assertEquals(i + 1, this.rs.getInt(1));
            }
        }
    } finally {
        multiStmt.close();
        multiConn.close();
    }
}
 

import java.sql.Statement; //导入方法依赖的package包/类
public void testUsageAdvisorOnZeroRowResultSet() throws Exception {
    Connection advisorConn = null;
    Statement advisorStmt = null;

    try {
        Properties props = new Properties();
        props.setProperty("useUsageAdvisor", "true");

        advisorConn = getConnectionWithProps(props);

        advisorStmt = advisorConn.createStatement();

        StandardLogger.startLoggingToBuffer();

        this.rs = advisorStmt.executeQuery("SELECT 1, 2 LIMIT 0");
        this.rs.next();
        this.rs.close();

        advisorStmt.close();

        advisorStmt = advisorConn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);

        advisorStmt.setFetchSize(Integer.MIN_VALUE);

        this.rs = advisorStmt.executeQuery("SELECT 1, 2 LIMIT 0");
        this.rs.next();
        this.rs.close();

        if (versionMeetsMinimum(5, 0, 2)) {
            advisorConn.close();

            props.setProperty("useCursorFetch", "true");
            props.setProperty("useServerPrepStmts", "true");

            advisorConn = getConnectionWithProps(props);

            advisorStmt = advisorConn.createStatement();
            advisorStmt.setFetchSize(1);

            this.rs = advisorStmt.executeQuery("SELECT 1, 2 LIMIT 0");
            StandardLogger.startLoggingToBuffer();
            this.rs.next();
            this.rs.close();
        }

        assertEquals(-1, StandardLogger.getBuffer().toString()
                .indexOf(Messages.getString("ResultSet.Possible_incomplete_traversal_of_result_set").substring(0, 10)));
    } finally {
        StandardLogger.dropBuffer();

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

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

import java.sql.Statement; //导入方法依赖的package包/类
private static Statement streamingStatementFrom(Connection connection) throws SQLException {
    Statement statement = connection.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
    statement.setFetchSize(MIN_VALUE);
    return statement;
}