We Keep Coding

Why ResultSet don't return the data from MySQL

I'm tying to get an image from MySQL database and show in a JLabel, but when I execute the query and try to get the bytes from the ResultSet it returns an empty array.
I tested the connection, and it is working, tested the query and its also working.
try {
conn = getConnection();
pst = conn.prepareStatement("select * from imagem where serial_imagem = 123658");
rs = pst.executeQuery()
if (rs.next()) {
image = rs.getBytes("img_imagem");
}
}catch (Exception e) {
e.printStackTrace();
}

The code does not close and thus leaks resources. The somewhat ugly Try-With-Resources syntax ensures closing connection, statement and result set, even on returning/exception.
One could make explicit with Optional whether the image was found in the table or not.
Optional.of also guarantees that the field in the database must not contain an SQL NULL value.
Optional<byte[]> loadImageFromDatabase(String imageM) throws SQLException {
String sql = "select img_imagem from imagem where serial_imagem = ?";
try (Connection conn = getConnection();
PreparedStatement pst = conn.prepareStatement(sql)) {
pst.setString(1, imageM);
try (ResultSet rs = pst.executeQuery()) {
if (rs.next()) {
return Optional.of(rs.getBytes(1)); // ofNullable
} else {
return Optional.empty();
}
}
}
}
Usage:
try {
Optional<byte[]> img = loadImageFromDatabase(jtextField1.getText().trim());
img.ifPresent(image -> {
...
});
} catch (SQLException e) {
There is still to remark that I personally do not often use ResultSet.getBytes, but rather getInputStream. Depends on the image size and creation code.

Using Symbols with Prepared Statement parameters in JAVA

How do I used % in the parameter for the code below? it works if I just use it directly in the query without the rset.setString(). Thanks!
try (Connection con = DriverManager.getConnection(connection);
PreparedStatement prepstmt = con.prepareStatement("SELECT {fn SUBSTRING(VS_TABLE_KEY,3,18)} FROM VP_SD_TABLE WHERE {fn SUBSTRING(VS_DESCRIPT,3,62)} LIKE ?");
ResultSet rset = prepstmt.executeQuery()
) {
prepstmt.setString(1,"DI%");
while (rset.next()) {
System.out.println(rset.getString("VS_TABLE_KEY"));
}
} catch (SQLException e) {
e.printStackTrace();
System.exit(1);
}

You're executing the query before you set the parameter. You should get an exception when you run this code, not just an empty result set.

Is it necessary to close PreparedStatement before preparing another Statement

Is it necessary to close ResultSet and PreparedStatement within one db.getConnection()? For the example below:
Connection conn = db.getConnection();
PreparedStatement pstmt = conn.prepareStatement(firstsql);
ResultSet r = pstmt.executeQuery();
// do something with the ResultSet
r.close();
pstmt.close(); // do I need close the r and pstmt here?
PreparedStatement pstmt = conn.prepareStatement(secondsql);
ResultSet r = pstmt.executeQuery();
// do something with the ResultSet again
r.close();
pstmt.close();
conn.close();
return null;
Are the codes of line 5 and line 6 necessary?

Strictly speaking, it is not necessary because you can have multiple prepared statements opened at the same time. What is necessary is to close every opened resource if it is not going to be utilised later.
Looking at your code, it doesn't ensure that the statement are, in fact, closed.
To ensure this, every close operation must be done inside a finally block: this way, it will executed whether the operation succeded or not.
Sample code:
PreparedStatement pstmt = null;
ResultSet r = null;
try {
pstmt = conn.prepareStatement(firstsql);
r = pstmt.executeQuery();
// do something with the ResultSet
} finally {
if (r != null) {
try {
r.close();
} catch (SQLException e) {
//log error
}
}
if (pstmt != null) {
try {
pstmt.close();
} catch (SQLException e) {
//log error
}
}
}
//and do it again
This code can be greatly simplified if you are using Java 7 with the try-with-resources statement:
try (PreparedStatement pstmt = conn.prepareStatement(firstsql);
ResultSet r = pstmt.executeQuery();) {
// do something with the ResultSet
}

No. You can have multiple statements open at the same time. But you must close them eventually.
The code you've posted doesn't compile, and if it did it would have a resource leak, but that's a different issue from the question in your title.

java.sql.SQLException: Closed statement: next

I have the following method which uses JDBC to get data from the DB:
public List<QueryHolder> getData(String Name) throws SQLException {
OracleDataSource ds;
ds = new OracleDataSource();
String url="jdbc:oracle:thin:#192.***.*.**:1521/dbg";
ds.setURL(url);
Connection conn = null;
conn=ds.getConnection("name","password");
SQL_Str = "SELECT ASM4EVLENMEEHLIYETBELGESI.DAMATSOYAD,ASM4EVLENMEEHLIYETBELGESI.DAMATBABAADI,ASM4EVLENMEEHLIYETBELGESI.DAMATANNEADI FROM ASM4EVLENMEEHLIYETBELGESI where DAMATSOYAD like ('%"
+ Name + "%')";
Statement ps = conn.createStatement();
if (ps == null)
throw new SQLException("Can't get data source");
rs = ps.executeQuery(SQL_Str);
ps.close();
if (con != null) {
con.close();
}
if (rs == null)
throw new SQLException("Can't get data source");
List<QueryHolder> list = new ArrayList<QueryHolder>();
while (rs.next()) { // <-- This is line 89.
QueryHolder que = new QueryHolder();
que.setSoyad(rs.getString("DAMATSOYAD"));
que.setBabaadi(rs.getString("DAMATANNEADI"));
que.setAnneadi(rs.getString("DAMATBABAADI"));
list.add(que);
}
return list;
}
However, when I run this method, it throws the following exception:
java.sql.SQLException: Closed statement: next
oracle.jdbc.driver.DatabaseError.throwSqlException(DatabaseError.java:113)
oracle.jdbc.driver.DatabaseError.throwSqlException(DatabaseError.java:147)
oracle.jdbc.driver.OracleResultSetImpl.next(OracleResultSetImpl.java:187)
Que.Query.getData(Query.java:89)
...
How is this caused and how can I solve it?

Correct closing order :
The following procedures should be done (in order)
ResultSet
PreparedStatement
Connection.
Edited code
Statement ps = conn.createStatement();
...
rs = ps.executeQuery(SQL_Str);
...
while (rs.next()) { // <-- This is line 89.
...
}
ps.close();
con.close();
return list;

It is a good practice to keep you ps.close(); or other closing statements in the finally block. Instead of handling Exception on the method label use try and catch instead.
the problem in your case is you closed the Statement before and trying to iterate through the ResultSet to just put your ps.close(); after the while block
Edit:
do it something like this
public returnType methodname()
{
try{
//your boilerplate code
return whateverYouWantToReturn;
}
catch(AppropriateExceptionClass e)
{
e.printStackTrace();
}
finally
{
//closing statements
}
return null;
}

The execution of
ps.close();
is in the wrong place.
You have to close the Statement after having iterate on its result set (that is, just close ps after the while loop).

PSQLException: this ResultSet is closed

i've occours this strange error for the first time in my life, and i don't know what does it means. I've a class that retrieve information from a table on a postgresql database, do some operations and return an arraylist with parsed element:
ResultSet rs = ProduttoreDCS.getProduttori();
System.out.println("Recuperato result set produttori");
ArrayList<String[]> res = new ArrayList<String[]>();
while (rs.next()) {
String[] current = new String[6];
current[0] = Integer.toString(rs.getInt("partita_iva"));
current[1] = rs.getString("nome");
current[2] = rs.getString("cognome");
current[3] = rs.getString("via_sede");
current[4] = rs.getString("citta_sede");
current[5] = rs.getString("provincia_sede");
res.add(current);
current = null;
}
return res;
the error is on "while" line.
public static ResultSet getProduttori() throws ClassNotFoundException, SQLException {
/*
* retrieve all record from produttori table
*/
Connection conn = null;
ResultSet res = null;
Statement stmt = null;
String query = "SELECT * FROM produttore";
conn = ConnectionManager.getConnection();
System.out.println("Connection obtained by ProduttoreDCS class");
stmt = conn.createStatement();
res = stmt.executeQuery(query);
stmt.close();
conn.close();
return res;
}

I've encountered the same problem by running the wrong combination of:
Postgres version;
Hibernate dialect;
postgres jdbc driver;
Updating all to the latest version solved the problem for me.
P.S. I know this is not what OP was asking, but this is the first result in Google when you search for the problem.

when you close the connection object in your getProduttori method, your result set will be automatically closed. when you try to re use it , it will be null.
ResultSet rs = ProduttoreDCS.getProduttori();
= null, as you have closed the connection in getProduttori
method, which will automatically close the resultset
thus, it returns null.
From Connection#close
Releases this Connection object's database and JDBC resources
immediately instead of waiting for them to be automatically released.
applies same when closing the Statement as well.For your code to work don't close Statement and Connection untill you get the rows.
#Baadshah has already shown you the standard way. If you are using java 7+ you can make use of try-with-resource block, which would make your life simpler.
try(Connection conn = gettheconn){
get the statement here
get the result set
perform your ops
}
catch(SQLException ex){
ex.printstacktrace();
}
If you observe, there is no finally block, your connection object will be closed once you exit the try block automatically.you don't have to explicity call Connection#close()

As per Docs
A ResultSet object is automatically closed when the Statement object that generated it is closed, re-executed, or used to retrieve the next result from a sequence of multiple results.
You are closed the connection and then you are iterating ,where it is null.Please read the data and then close the connection.
A good practice here is
Connection conn = null;
PreparedStatement stmt = null;
ResultSet rs = null;
try {
conn =
stmt = conn.prepareStatement("sql");
rs = stmt.executeQuery();
//DO SOME THING HERE
} catch {
// Error Handling
} finally {
try { if (rs != null) rs.close(); } catch (Exception e) {};
try { if (stmt != null) stmt.close(); } catch (Exception e) {};
try { if (conn != null) conn.close(); } catch (Exception e) {};
}

This is the problem:
stmt.close();
conn.close();
You're closing the connection to the database. You can't do that until you've read the data - otherwise how is the ResultSet going to read it? Maybe it will have read some data in to start with, but it's not meant to be a disconnected object.
In particular, from the docuemntation for ResultSet.close:
Note: A ResultSet object is automatically closed by the Statement object that generated it when that Statement object is closed, re-executed, or is used to retrieve the next result from a sequence of multiple results.

Closing the connection makes the resultSet go away.
A ResultSet is not a container you can use to pass data around in, it's only a wrapper around a cursor. You should run through the resultSet contents and copy them into a data structure, then return the data structure. You are already doing that, but you need to do it before closing the statement and connection.
Change the code to:
public static List<String[]> getProduttori() throws ClassNotFoundException, SQLException {
ArrayList<String[]> res = new ArrayList<String[]>();
/*
* retrieve all record from produttori table
*/
Connection conn = null;
ResultSet rs = null;
Statement stmt = null;
String query = "SELECT * FROM produttore";
conn = ConnectionManager.getConnection();
try {
System.out.println("Connection obtained by ProduttoreDCS class");
stmt = conn.createStatement();
try {
rs = stmt.executeQuery(query);
while (rs.next()) {
String[] current = new String[6];
current[0] = Integer.toString(rs.getInt("partita_iva"));
current[1] = rs.getString("nome");
current[2] = rs.getString("cognome");
current[3] = rs.getString("via_sede");
current[4] = rs.getString("citta_sede");
current[5] = rs.getString("provincia_sede");
res.add(current);
}
return res;
} finally {
try {
stmt.close();
} catch (SQLException e) {
log.error(e);
}
}
} finally {
try {
conn.close();
} catch (SQLException e) {
log.error(e);
}
}
}