iSharkFly-Docs/java-tutorials
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixed issues with adding the 2nd record

Browse Source
This commit is contained in:
Venkata Kiran Surapaneni 2019-01-24 13:16:56 -05:00
parent eb8f0cf66c
commit 48bad82439
1 changed files with 268 additions and 286 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

554
persistence-modules/core-java-persistence/src/test/java/com/baeldung/jdbc/ResultSetLiveTest.java
View File

@ -20,329 +20,311 @@ import org.junit.FixMethodOrder;
import org.junit.Test; import org.junit.Test;
import org.junit.runners.MethodSorters; import org.junit.runners.MethodSorters;
import junit.framework.Assert;
@FixMethodOrder(MethodSorters.NAME_ASCENDING) @FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class ResultSetLiveTest { public class ResultSetLiveTest {
private static final Logger logger = Logger.getLogger(ResultSetLiveTest.class); private static final Logger logger = Logger.getLogger(ResultSetLiveTest.class);
private final Employee expectedEmployee1 = new Employee(1, "John", 1000.0, "Developer"); private final Employee expectedEmployee1 = new Employee(1, "John", 1000.0, "Developer");
private final Employee updatedEmployee1 = new Employee(1, "John", 1100.0, "Developer"); private final Employee updatedEmployee1 = new Employee(1, "John", 1100.0, "Developer");
private final Employee expectedEmployee2 = new Employee(2, "Chris", 925.0, "DBA"); private final Employee expectedEmployee2 = new Employee(2, "Chris", 925.0, "DBA");
private final int rowCount = 2; private final int rowCount = 2;
private static Connection dbConnection; private static Connection dbConnection;
@BeforeClass @BeforeClass
public static void setup() throws ClassNotFoundException, SQLException { public static void setup() throws ClassNotFoundException, SQLException {
Class.forName("com.mysql.cj.jdbc.Driver"); Class.forName("com.mysql.cj.jdbc.Driver");
dbConnection = DriverManager.getConnection("jdbc:mysql://localhost:3306/myDB?noAccessToProcedureBodies=true", dbConnection = DriverManager.getConnection("jdbc:mysql://localhost:3306/myDB?noAccessToProcedureBodies=true", "user1", "pass");
"user1", "pass"); String tableSql = "CREATE TABLE IF NOT EXISTS employees (emp_id int PRIMARY KEY AUTO_INCREMENT, name varchar(30), position varchar(30), salary double)";
String tableSql = "CREATE TABLE IF NOT EXISTS employees (emp_id int PRIMARY KEY AUTO_INCREMENT, name varchar(30), position varchar(30), salary double)"; try (Statement stmt = dbConnection.createStatement()) {
try (Statement stmt = dbConnection.createStatement()) { stmt.execute(tableSql);
stmt.execute(tableSql); try (PreparedStatement pstmt = dbConnection.prepareStatement("INSERT INTO employees(name, position, salary) values ('John', 'Developer', 1000.0)")) {
try (PreparedStatement pstmt = dbConnection.prepareStatement( pstmt.executeUpdate();
"INSERT INTO employees(name, position, salary) values ('John', 'Developer', 1000.0)")) { }
pstmt.executeUpdate(); }
} }
}
}
@Test @Test
public void givenDbConnectionA_whenARetreiveByColumnNames_thenCorrect() throws SQLException { public void givenDbConnectionA_whenRetreiveByColumnNames_thenCorrect() throws SQLException {
Employee employee = null; Employee employee = null;
try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees"); try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees"); ResultSet rs = pstmt.executeQuery()) {
ResultSet rs = pstmt.executeQuery()) { while (rs.next()) {
while (rs.next()) { String name = rs.getString("name");
String name = rs.getString("name"); Integer empId = rs.getInt("emp_id");
Integer empId = rs.getInt("emp_id"); Double salary = rs.getDouble("salary");
Double salary = rs.getDouble("salary"); String position = rs.getString("position");
String position = rs.getString("position"); employee = new Employee(empId, name, salary, position);
employee = new Employee(empId, name, salary, position); }
} }
}
assertEquals("Employee information retreived by column names.", expectedEmployee1, employee); assertEquals("Employee information retreived by column names.", expectedEmployee1, employee);
} }
@Test @Test
public void givenDbConnectionB_whenBRetreiveByColumnIds_thenCorrect() throws SQLException { public void givenDbConnectionB_whenRetreiveByColumnIds_thenCorrect() throws SQLException {
Employee employee = null; Employee employee = null;
try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees"); try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees"); ResultSet rs = pstmt.executeQuery()) {
ResultSet rs = pstmt.executeQuery()) { while (rs.next()) {
while (rs.next()) { Integer empId = rs.getInt(1);
Integer empId = rs.getInt(1); String name = rs.getString(2);
String name = rs.getString(2); String position = rs.getString(3);
String position = rs.getString(3); Double salary = rs.getDouble(4);
Double salary = rs.getDouble(4); employee = new Employee(empId, name, salary, position);
employee = new Employee(empId, name, salary, position); }
} }
}
assertEquals("Employee information retreived by column ids.", expectedEmployee1, employee); assertEquals("Employee information retreived by column ids.", expectedEmployee1, employee);
} }
@Test @Test
public void givenDbConnectionD_whenInsertRow_thenCorrect() throws SQLException { public void givenDbConnectionD_whenInsertRow_thenCorrect() throws SQLException {
int rowCount = 0; int rowCount = 0;
try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees", try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees", ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet rs = pstmt.executeQuery()) {
ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet rs = pstmt.executeQuery()) { rs.moveToInsertRow();
rs.moveToInsertRow(); rs.updateString("name", "Chris");
rs.updateString("name", "Venkat"); rs.updateString("position", "DBA");
rs.updateString("position", "DBA"); rs.updateDouble("salary", 925.0);
rs.updateDouble("salary", 925.0); rs.insertRow();
rs.insertRow(); rs.moveToCurrentRow();
rs.moveToCurrentRow(); rs.last();
rs.last(); rowCount = rs.getRow();
rowCount = rs.getRow(); }
}
assertEquals("Row Count after inserting a row", 2, rowCount); assertEquals("Row Count after inserting a row", 2, rowCount);
} }
private Employee populateResultSet(ResultSet rs) throws SQLException { private Employee populateResultSet(ResultSet rs) throws SQLException {
Employee employee; Employee employee;
String name = rs.getString("name"); String name = rs.getString("name");
Integer empId = rs.getInt("emp_id"); Integer empId = rs.getInt("emp_id");
Double salary = rs.getDouble("salary"); Double salary = rs.getDouble("salary");
String position = rs.getString("position"); String position = rs.getString("position");
employee = new Employee(empId, name, salary, position); employee = new Employee(empId, name, salary, position);
return employee; return employee;
} }
@Test @Test
public void givenDbConnectionE_whenRowCount_thenCorrect() throws SQLException { public void givenDbConnectionE_whenRowCount_thenCorrect() throws SQLException {
int numOfRows = 0; int numOfRows = 0;
try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees", try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees", ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet rs = pstmt.executeQuery()) {
ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet rs = pstmt.executeQuery()) { rs.last();
rs.last(); numOfRows = rs.getRow();
numOfRows = rs.getRow(); }
}
assertEquals("Num of rows", rowCount, numOfRows); assertEquals("Num of rows", rowCount, numOfRows);
} }
@Test @Test
public void givenDbConnectionG_whenAbsoluteNavigation_thenCorrect() throws SQLException { public void givenDbConnectionG_whenAbsoluteNavigation_thenCorrect() throws SQLException {
Employee secondEmployee = null; Employee secondEmployee = null;
try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees", try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees", ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet rs = pstmt.executeQuery()) {
ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet rs = pstmt.executeQuery()) { rs.absolute(2);
rs.absolute(2); secondEmployee = populateResultSet(rs);
secondEmployee = populateResultSet(rs); }
}
assertEquals("Absolute navigation", expectedEmployee2, secondEmployee); assertEquals("Absolute navigation", expectedEmployee2, secondEmployee);
} }
@Test @Test
public void givenDbConnectionH_whenLastNavigation_thenCorrect() throws SQLException { public void givenDbConnectionH_whenLastNavigation_thenCorrect() throws SQLException {
Employee secondEmployee = null; Employee secondEmployee = null;
try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees", try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees", ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet rs = pstmt.executeQuery()) {
ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet rs = pstmt.executeQuery()) { rs.last();
rs.last(); secondEmployee = populateResultSet(rs);
secondEmployee = populateResultSet(rs); }
}
assertEquals("Using Last", expectedEmployee2, secondEmployee); assertEquals("Using Last", expectedEmployee2, secondEmployee);
} }
@Test @Test
public void givenDbConnectionI_whenNavigation_thenCorrect() throws SQLException { public void givenDbConnectionI_whenNavigation_thenCorrect() throws SQLException {
Employee firstEmployee = null; Employee firstEmployee = null;
try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees", try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees", ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet rs = pstmt.executeQuery()) {
ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet rs = pstmt.executeQuery()) { while (rs.next()) {
while (rs.next()) { Employee employee = populateResultSet(rs);
Employee employee = populateResultSet(rs); }
} rs.beforeFirst();
rs.beforeFirst(); while (rs.next()) {
while (rs.next()) { Employee employee = populateResultSet(rs);
Employee employee = populateResultSet(rs); }
} rs.first();
rs.first(); while (rs.next()) {
while (rs.next()) { Employee employee = populateResultSet(rs);
Employee employee = populateResultSet(rs); }
} while (rs.previous()) {
while (rs.previous()) { Employee employee = populateResultSet(rs);
Employee employee = populateResultSet(rs); }
} rs.afterLast();
rs.afterLast(); while (rs.previous()) {
while (rs.previous()) { Employee employee = populateResultSet(rs);
Employee employee = populateResultSet(rs); }
} rs.last();
rs.last(); while (rs.previous()) {
while (rs.previous()) { firstEmployee = populateResultSet(rs);
firstEmployee = populateResultSet(rs); }
} }
}
assertEquals("Several Navigation Options", updatedEmployee1, firstEmployee); assertEquals("Several Navigation Options", updatedEmployee1, firstEmployee);
} }
@Test @Test
public void givenDbConnectionJ_whenClosedCursor_thenCorrect() throws SQLException { public void givenDbConnectionJ_whenClosedCursor_thenCorrect() throws SQLException {
int numOfRows = 0; int numOfRows = 0;
dbConnection.setHoldability(ResultSet.CLOSE_CURSORS_AT_COMMIT); dbConnection.setHoldability(ResultSet.CLOSE_CURSORS_AT_COMMIT);
try (Statement pstmt = dbConnection.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE, try (Statement pstmt = dbConnection.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE, ResultSet.CLOSE_CURSORS_AT_COMMIT)) {
ResultSet.CLOSE_CURSORS_AT_COMMIT)) { dbConnection.setAutoCommit(false);
dbConnection.setAutoCommit(false); pstmt.executeUpdate("INSERT INTO employees (name, salary,position) VALUES ('Chris',2100.0,'Manager')");
pstmt.executeUpdate("INSERT INTO employees (name, salary,position) VALUES ('Chris',2100.0,'Manager')"); ResultSet rs = pstmt.executeQuery("select * from employees");
ResultSet rs = pstmt.executeQuery("select * from employees"); dbConnection.commit();
dbConnection.commit(); while (rs.next()) {
while (rs.next()) { Employee employee = populateResultSet(rs);
Employee employee = populateResultSet(rs); }
} rs.last();
rs.last(); numOfRows = rs.getRow();
numOfRows = rs.getRow(); }
}
assertEquals("Inserted using close cursor after commit", 3, numOfRows); assertEquals("Inserted using close cursor after commit", 3, numOfRows);
} }
@Test @Test
public void givenDbConnectionK_whenUpdate_thenCorrect() throws SQLException { public void givenDbConnectionK_whenUpdate_thenCorrect() throws SQLException {
int numOfRows = 0; int numOfRows = 0;
try (Statement pstmt = dbConnection.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE, try (Statement pstmt = dbConnection.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE, ResultSet.HOLD_CURSORS_OVER_COMMIT)) {
ResultSet.HOLD_CURSORS_OVER_COMMIT)) { dbConnection.setAutoCommit(false);
dbConnection.setAutoCommit(false); pstmt.executeUpdate("INSERT INTO employees (name, salary,position) VALUES ('Michael',1200.0,'Consultant')");
pstmt.executeUpdate("INSERT INTO employees (name, salary,position) VALUES ('Michael',1200.0,'Consultant')"); ResultSet rs = pstmt.executeQuery("select * from employees");
ResultSet rs = pstmt.executeQuery("select * from employees"); dbConnection.commit();
dbConnection.commit(); while (rs.next()) {
while (rs.next()) { Employee employee = populateResultSet(rs);
Employee employee = populateResultSet(rs); }
} rs.last();
rs.last(); numOfRows = rs.getRow();
numOfRows = rs.getRow(); }
}
assertEquals("Inserted using hold cursor after commit", 4, numOfRows); assertEquals("Inserted using hold cursor after commit", 4, numOfRows);
} }
@Test @Test
public void givenDbConnectionL_whenDelete_thenCorrect() throws SQLException { public void givenDbConnectionL_whenDelete_thenCorrect() throws SQLException {
int numOfRows = 0; int numOfRows = 0;
try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees", try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees", ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet rs = pstmt.executeQuery()) {
ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet rs = pstmt.executeQuery()) { rs.absolute(3);
rs.absolute(3); rs.deleteRow();
rs.deleteRow(); rs.last();
rs.last(); numOfRows = rs.getRow();
numOfRows = rs.getRow(); }
}
assertEquals("Deleted row", 3, numOfRows); assertEquals("Deleted row", 3, numOfRows);
} }
@Test @Test
public void givenDbConnectionC_whenUpdate_thenCorrect() throws SQLException { public void givenDbConnectionC_whenUpdate_thenCorrect() throws SQLException {
Employee employee = null; Employee employee = null;
try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees", try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees", ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet rs = pstmt.executeQuery()) {
ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet rs = pstmt.executeQuery()) { while (rs.next()) {
while (rs.next()) {
rs.updateDouble("salary", 1100.0);
rs.updateRow();
rs.refreshRow();
String name = rs.getString("name");
Integer empId = rs.getInt("emp_id");
Double salary = rs.getDouble("salary");
String position = rs.getString("position");
employee = new Employee(empId, name, salary, position);
}
}
assertEquals("Employee information updated successfully.", updatedEmployee1, employee); Assert.assertEquals(1000.0, rs.getDouble("salary"));
}
@Test rs.updateDouble("salary", 1100.0);
public void givenDbConnectionE_whenDBMetaInfo_thenCorrect() throws SQLException { rs.updateRow();
DatabaseMetaData dbmd = dbConnection.getMetaData();
boolean supportsTypeForward = dbmd.supportsResultSetType(ResultSet.TYPE_FORWARD_ONLY);
boolean supportsTypeScrollSensitive = dbmd.supportsResultSetType(ResultSet.TYPE_SCROLL_SENSITIVE);
boolean supportsTypeScrollInSensitive = dbmd.supportsResultSetType(ResultSet.TYPE_SCROLL_INSENSITIVE);
boolean supportsCloseCursorsAtCommit = dbmd.supportsResultSetHoldability(ResultSet.CLOSE_CURSORS_AT_COMMIT);
boolean supportsHoldCursorsAtCommit = dbmd.supportsResultSetHoldability(ResultSet.HOLD_CURSORS_OVER_COMMIT);
boolean concurrency4TypeFwdNConcurReadOnly = dbmd.supportsResultSetConcurrency(ResultSet.TYPE_FORWARD_ONLY,
ResultSet.CONCUR_READ_ONLY);
boolean concurrency4TypeFwdNConcurUpdatable = dbmd.supportsResultSetConcurrency(ResultSet.TYPE_FORWARD_ONLY,
ResultSet.CONCUR_UPDATABLE);
boolean concurrency4TypeScrollInSensitiveNConcurUpdatable = dbmd
.supportsResultSetConcurrency(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);
boolean concurrency4TypeScrollInSensitiveNConcurReadOnly = dbmd
.supportsResultSetConcurrency(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
boolean concurrency4TypeScrollSensitiveNConcurUpdatable = dbmd
.supportsResultSetConcurrency(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE);
boolean concurrency4TypeScrollSensitiveNConcurReadOnly = dbmd
.supportsResultSetConcurrency(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
int rsHoldability = dbmd.getResultSetHoldability();
assertEquals("checking scroll sensitivity and concur updates : ", true, Assert.assertEquals(1100.0, rs.getDouble("salary"));
concurrency4TypeScrollInSensitiveNConcurUpdatable);
}
@Test String name = rs.getString("name");
public void givenDbConnectionF_whenRSMetaInfo_thenCorrect() throws SQLException { Integer empId = rs.getInt("emp_id");
int columnCount = 0; Double salary = rs.getDouble("salary");
try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees", String position = rs.getString("position");
ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet rs = pstmt.executeQuery()) { employee = new Employee(empId, name, salary, position);
ResultSetMetaData metaData = rs.getMetaData(); }
columnCount = metaData.getColumnCount(); }
for (int i = 1; i <= columnCount; i++) { }
String catalogName = metaData.getCatalogName(i);
String className = metaData.getColumnClassName(i);
String label = metaData.getColumnLabel(i);
String name = metaData.getColumnName(i);
String typeName = metaData.getColumnTypeName(i);
Integer type = metaData.getColumnType(i);
String tableName = metaData.getTableName(i);
String schemaName = metaData.getSchemaName(i);
boolean isAutoIncrement = metaData.isAutoIncrement(i);
boolean isCaseSensitive = metaData.isCaseSensitive(i);
boolean isCurrency = metaData.isCurrency(i);
boolean isDefiniteWritable = metaData.isDefinitelyWritable(i);
boolean isReadOnly = metaData.isReadOnly(i);
boolean isSearchable = metaData.isSearchable(i);
boolean isReadable = metaData.isReadOnly(i);
boolean isSigned = metaData.isSigned(i);
boolean isWritable = metaData.isWritable(i);
int nullable = metaData.isNullable(i);
}
}
assertEquals("column count", 4, columnCount); @Test
} public void givenDbConnectionE_whenDBMetaInfo_thenCorrect() throws SQLException {
DatabaseMetaData dbmd = dbConnection.getMetaData();
boolean supportsTypeForward = dbmd.supportsResultSetType(ResultSet.TYPE_FORWARD_ONLY);
boolean supportsTypeScrollSensitive = dbmd.supportsResultSetType(ResultSet.TYPE_SCROLL_SENSITIVE);
boolean supportsTypeScrollInSensitive = dbmd.supportsResultSetType(ResultSet.TYPE_SCROLL_INSENSITIVE);
boolean supportsCloseCursorsAtCommit = dbmd.supportsResultSetHoldability(ResultSet.CLOSE_CURSORS_AT_COMMIT);
boolean supportsHoldCursorsAtCommit = dbmd.supportsResultSetHoldability(ResultSet.HOLD_CURSORS_OVER_COMMIT);
boolean concurrency4TypeFwdNConcurReadOnly = dbmd.supportsResultSetConcurrency(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
boolean concurrency4TypeFwdNConcurUpdatable = dbmd.supportsResultSetConcurrency(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
boolean concurrency4TypeScrollInSensitiveNConcurUpdatable = dbmd.supportsResultSetConcurrency(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);
boolean concurrency4TypeScrollInSensitiveNConcurReadOnly = dbmd.supportsResultSetConcurrency(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
boolean concurrency4TypeScrollSensitiveNConcurUpdatable = dbmd.supportsResultSetConcurrency(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE);
boolean concurrency4TypeScrollSensitiveNConcurReadOnly = dbmd.supportsResultSetConcurrency(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
int rsHoldability = dbmd.getResultSetHoldability();
@Test assertEquals("checking scroll sensitivity and concur updates : ", true, concurrency4TypeScrollInSensitiveNConcurUpdatable);
public void givenDbConnectionM_whenDelete_thenCorrect() throws SQLException { }
PreparedStatement pstmt = null;
ResultSet rs = null;
List<Employee> listOfEmployees = new ArrayList<Employee>();
try {
pstmt = dbConnection.prepareStatement("select * from employees", ResultSet.TYPE_FORWARD_ONLY,
ResultSet.CONCUR_READ_ONLY);
pstmt.setFetchSize(2);
rs = pstmt.executeQuery();
rs.setFetchSize(1);
while (rs.next()) {
Employee employee = populateResultSet(rs);
listOfEmployees.add(employee);
}
} catch (Exception e) {
throw e;
} finally {
if (rs != null)
rs.close();
if (pstmt != null)
pstmt.close();
}
assertEquals(3, listOfEmployees.size()); @Test
} public void givenDbConnectionF_whenRSMetaInfo_thenCorrect() throws SQLException {
int columnCount = 0;
try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees", ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet rs = pstmt.executeQuery()) {
ResultSetMetaData metaData = rs.getMetaData();
columnCount = metaData.getColumnCount();
for (int i = 1; i <= columnCount; i++) {
String catalogName = metaData.getCatalogName(i);
String className = metaData.getColumnClassName(i);
String label = metaData.getColumnLabel(i);
String name = metaData.getColumnName(i);
String typeName = metaData.getColumnTypeName(i);
Integer type = metaData.getColumnType(i);
String tableName = metaData.getTableName(i);
String schemaName = metaData.getSchemaName(i);
boolean isAutoIncrement = metaData.isAutoIncrement(i);
boolean isCaseSensitive = metaData.isCaseSensitive(i);
boolean isCurrency = metaData.isCurrency(i);
boolean isDefiniteWritable = metaData.isDefinitelyWritable(i);
boolean isReadOnly = metaData.isReadOnly(i);
boolean isSearchable = metaData.isSearchable(i);
boolean isReadable = metaData.isReadOnly(i);
boolean isSigned = metaData.isSigned(i);
boolean isWritable = metaData.isWritable(i);
int nullable = metaData.isNullable(i);
}
}
@AfterClass assertEquals("column count", 4, columnCount);
public static void closeConnection() throws SQLException { }
PreparedStatement deleteStmt = dbConnection.prepareStatement("drop table employees",
ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE); @Test
deleteStmt.execute(); public void givenDbConnectionM_whenDelete_thenCorrect() throws SQLException {
dbConnection.close(); PreparedStatement pstmt = null;
} ResultSet rs = null;
List<Employee> listOfEmployees = new ArrayList<Employee>();
try {
pstmt = dbConnection.prepareStatement("select * from employees", ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
pstmt.setFetchSize(2);
rs = pstmt.executeQuery();
rs.setFetchSize(1);
while (rs.next()) {
Employee employee = populateResultSet(rs);
listOfEmployees.add(employee);
}
} catch (Exception e) {
throw e;
} finally {
if (rs != null)
rs.close();
if (pstmt != null)
pstmt.close();
}
assertEquals(3, listOfEmployees.size());
}
@AfterClass
public static void closeConnection() throws SQLException {
PreparedStatement deleteStmt = dbConnection.prepareStatement("drop table employees", ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);
deleteStmt.execute();
dbConnection.close();
}
} }