PreparedStatement and 'Order by'

Question

How can a PreparedStatement be made in this situation?
String query = " Select * from myTable where id=? Order by ? ? ";
PreparedStatement  ps = con.prepareStatement( query);
ps.setInt(1,userID);
ps.setString (2, columnName );
ps.setString (3, ascOrDesc );The problem is the 3rd value. You cannot stick 2 question marks together like that. However, if I do the following it compiles, but the query doesn't place the values in order.
String query = " Select * from myTable where id=? Order by ?  "+ascOrDesc;
PreparedStatement  ps = con.prepareStatement( query);
ps.setInt(1,userID);
ps.setString (2, columnName );So, what to do?

Answer 1

Just to make the answer more clear, you cannot use the same prepared statements for ascending and descending sorts. You need one for each.
String query = " Select * from myTable where id=?
Order by ? asc ";
PreparedStatement  ps = con.prepareStatement(  query );
ps.setInt(1,userID);
ps.setString (2, columnName );Of course, you can refactor this into a single method, something like:
static final String MYTABLE_QUERY = "Select * from myTable where id=? Order by ?";
public String getMyTableQuerySQL( boolean isAscending )
     return MYTABLE_QUERY + ( isAscending ? " asc" : " desc" );
PreparedStatement st = con.prepareStatement( getMyTableQuerySQL( isAscending ) );Another cool thing to do (that belongs in another thread) is to wrap Connection in an envelope that implements the Connection interface and add a PreparedStatement cache. This optimally will be a PooledConnection. Here's a niave skeletal implementation:
First we'll write the statement cache we will be using. This is an LRU map using STATEMENT_CACHE_SIZE to set the max number of elements we want in the cache. I usually make this settable by a property with a default of 8.
    class StatementCache extends LinkedHashMap
        public StatementCache()
            super( STATEMENT_CACHE_SIZE, 0.75f, true );
        protected boolean removeEldestEntry( final Map.Entry eldest )
            if ( size() <= STATEMENT_CACHE_SIZE )
                return false;
            else
                final CachedPreparedStatement ps =
                    (CachedPreparedStatement)eldest.getValue();
                if ( ps.isActive() )
                    return false;
                try
                    ps.reallyClose(); // NOTE: Really close the statement
                catch ( SQLException e )
                    e.printStackTrace();
                return true;
    }Now we need to wrap PreparedStatement:
class CachedPreparedStatement implements PreparedStatement
    /** The real statement we are delegating to */
    private PreparedStatement m_statement;
    /** We change the behavior of close to just flip this switch. */
    protected boolean m_active = true;
    public CachedPreparedStatement( final String sql, final Connection con ) throws SQLException
        m_statement = con.prepareStatement( sql );
    public boolean isActive()
        return m_active;
    public boolean setActive( boolean isActive )
        m_active = isActive;
    public void close() throws SQLException
        clearParameters();
        try
            clearWarnings();
        catch ( SQLException e )
            e.printStackTrace();
        // mark it as no longer active
        setActive( false );
    public void reallyClose() throws SQLException
        setActive( false );
        m_statement.close();
    // now just delegate all the rest of the interface methods to m_statement
}Finally, we wrap Connection:
class PooledConnection extends implements Connection
    /** A map of cached statements */
    private Map m_statementCache = new StatementCache();
    /** The connection we are delegating to */
    private Connection m_connection;
    /** {@inheritDoc} */
    public PreparedStatement prepareStatement( final String sql )
        throws SQLException
        // create or fetch a cached prepared statement and activate
        final CachedPreparedStatement statement = (CachedPreparedStatement)
            m_statementCache.get( sql );
        if ( statement != null )
            statement.setActive( true );
            return statement;
        else
            // need to create a new one and cache it
            final CachedPreparedStatement ps =
                new CachedPreparedStatement( sql, m_connection );
            m_statementCache.put( sql, ps );
            return ps;
    // now just delegate the rest of the interface methods to m_connection
}The Connection class provided by your JDBC driver should close all open statements when the connection is closed. However, if you are not sure about this, you can implement #close on your Connection class to first iterate throught the cache and close each statement.