Congratulations, you've hit my favorite pet peeve with JDBC: Date class handling.
Basically databases usually support at least three forms of datetime fields which are date, time and timestamp. Each of these have a corresponding class in JDBC and each of them extend
java.util.Date. Quick semantics of each of these three are the following:
java.sql.Datecorresponds to SQL DATE which means it stores years, months and days while hour, minute, second and millisecond are ignored. Additionally
sql.Dateisn't tied to timezones.
java.sql.Timecorresponds to SQL TIME and as should be obvious, only contains information about hour, minutes, seconds and milliseconds.
java.sql.Timestampcorresponds to SQL TIMESTAMP which is exact date to the nanosecond (note that
util.Dateonly supports milliseconds!) with customizable precision.
One of the most common bugs when using JDBC drivers in relation to these three types is that the types are handled incorrectly. This means that
sql.Date is timezone specific,
sql.Time contains current year, month and day et cetera et cetera.
Depends on the SQL type of the field, really.
PreparedStatement has setters for all three values,
#setDate() being the one for
Do note that if you use
ps.setObject(fieldIndex, utilDateObject); you can actually give a normal
util.Date to most JDBC drivers which will happily devour it as if it was of the correct type but when you request the data afterwards, you may notice that you're actually missing stuff.
What I am saying that save the milliseconds/nanoseconds as plain longs and convert them to whatever objects you are using (obligatory joda-time plug). One hacky way which can be done is to store the date component as one long and time component as another, for example right now would be 20100221 and 154536123. These magic numbers can be used in SQL queries and will be portable from database to another and will let you avoid this part of JDBC/Java Date API:s entirely.