diff --git a/src/interfaces/jdbc/org/postgresql/jdbc1/AbstractJdbc1ResultSet.java b/src/interfaces/jdbc/org/postgresql/jdbc1/AbstractJdbc1ResultSet.java index e2674c96cb..67071fa84f 100644 --- a/src/interfaces/jdbc/org/postgresql/jdbc1/AbstractJdbc1ResultSet.java +++ b/src/interfaces/jdbc/org/postgresql/jdbc1/AbstractJdbc1ResultSet.java @@ -9,7 +9,7 @@ * Copyright (c) 2003, PostgreSQL Global Development Group * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc1/Attic/AbstractJdbc1ResultSet.java,v 1.20 2003/09/18 04:09:02 barry Exp $ + * $Header: /cvsroot/pgsql/src/interfaces/jdbc/org/postgresql/jdbc1/Attic/AbstractJdbc1ResultSet.java,v 1.21 2003/09/22 04:54:59 barry Exp $ * *------------------------------------------------------------------------- */ @@ -201,7 +201,11 @@ public abstract class AbstractJdbc1ResultSet implements BaseResultSet case Types.DOUBLE: case Types.FLOAT: case Types.DECIMAL: - s = (s.indexOf(".")==-1) ? s : s.substring(0,s.indexOf(".")); + int loc = s.indexOf("."); + if (loc!=-1 && Integer.parseInt(s.substring(loc+1,s.length()))==0) + { + s = s.substring(0,loc); + } break; case Types.CHAR: s = s.trim(); @@ -232,7 +236,11 @@ public abstract class AbstractJdbc1ResultSet implements BaseResultSet case Types.DOUBLE: case Types.FLOAT: case Types.DECIMAL: - s = (s.indexOf(".")==-1) ? s : s.substring(0,s.indexOf(".")); + int loc = s.indexOf("."); + if (loc!=-1 && Integer.parseInt(s.substring(loc+1,s.length()))==0) + { + s = s.substring(0,loc); + } break; case Types.CHAR: s = s.trim(); diff --git a/src/interfaces/jdbc/org/postgresql/test/jdbc2/DateTest.java b/src/interfaces/jdbc/org/postgresql/test/jdbc2/DateTest.java index 7c1f01a950..7d9ab2b42c 100644 --- a/src/interfaces/jdbc/org/postgresql/test/jdbc2/DateTest.java +++ b/src/interfaces/jdbc/org/postgresql/test/jdbc2/DateTest.java @@ -5,7 +5,7 @@ import junit.framework.TestCase; import java.sql.*; /* - * $Id: DateTest.java,v 1.5 2002/08/14 20:35:40 barry Exp $ + * $Id: DateTest.java,v 1.6 2003/09/22 04:55:00 barry Exp $ * * Some simple tests based on problems reported by users. Hopefully these will * help prevent previous problems from re-occuring ;-) @@ -15,6 +15,7 @@ public class DateTest extends TestCase { private Connection con; + private boolean testingSetDate = false; public DateTest(String name) { @@ -46,11 +47,23 @@ public class DateTest extends TestCase assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testdate", "'1970-06-02'"))); assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testdate", "'1999-08-11'"))); assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testdate", "'2001-02-13'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testdate", "'1950-04-02'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testdate", "'1970-11-30'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testdate", "'1988-01-01'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testdate", "'2003-07-09'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testdate", "'1934-02-28'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testdate", "'1969-04-03'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testdate", "'1982-08-03'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testdate", "'2012-03-15'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testdate", "'1912-05-01'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testdate", "'1971-12-15'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testdate", "'1984-12-03'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testdate", "'2000-01-01'"))); /* dateTest() contains all of the tests */ dateTest(); - assertEquals(4, stmt.executeUpdate("DELETE FROM " + "testdate")); + assertEquals(16, stmt.executeUpdate("DELETE FROM " + "testdate")); stmt.close(); } catch (Exception ex) @@ -80,13 +93,64 @@ public class DateTest extends TestCase ps.setDate(1, makeDate(2001, 2, 13)); assertEquals(1, ps.executeUpdate()); - + + ps.setObject(1, java.sql.Timestamp.valueOf("1950-04-02 12:00:00"), java.sql.Types.DATE); + assertEquals(1, ps.executeUpdate()); + + ps.setObject(1, java.sql.Timestamp.valueOf("1970-11-30 3:00:00"), java.sql.Types.DATE); + assertEquals(1, ps.executeUpdate()); + + ps.setObject(1, java.sql.Timestamp.valueOf("1988-1-1 13:00:00"), java.sql.Types.DATE); + assertEquals(1, ps.executeUpdate()); + + ps.setObject(1, java.sql.Timestamp.valueOf("2003-07-09 12:00:00"), java.sql.Types.DATE); + assertEquals(1, ps.executeUpdate()); + + ps.setObject(1, "1934-02-28", java.sql.Types.DATE); + assertEquals(1, ps.executeUpdate()); + + ps.setObject(1, "1969-04-3", java.sql.Types.DATE); + assertEquals(1, ps.executeUpdate()); + + ps.setObject(1, "1982-08-03", java.sql.Types.DATE); + assertEquals(1, ps.executeUpdate()); + + ps.setObject(1, "2012-3-15", java.sql.Types.DATE); + assertEquals(1, ps.executeUpdate()); + + ps.setObject(1, java.sql.Date.valueOf("1912-5-1"), java.sql.Types.DATE); + assertEquals(1, ps.executeUpdate()); + + ps.setObject(1, java.sql.Date.valueOf("1971-12-15"), java.sql.Types.DATE); + assertEquals(1, ps.executeUpdate()); + + ps.setObject(1, java.sql.Date.valueOf("1984-12-03"), java.sql.Types.DATE); + assertEquals(1, ps.executeUpdate()); + + ps.setObject(1, java.sql.Date.valueOf("2000-1-1"), java.sql.Types.DATE); + assertEquals(1, ps.executeUpdate()); + + ps.setObject(1, "1944-4-04-01", java.sql.Types.DATE); + assertEquals(1, ps.executeUpdate()); + + ps.setObject(1, "1970-01-1-10", java.sql.Types.DATE); + assertEquals(1, ps.executeUpdate()); + + ps.setObject(1, "1982-12-14+13", java.sql.Types.DATE); + assertEquals(1, ps.executeUpdate()); + + ps.setObject(1, "2010-08-3+05", java.sql.Types.DATE); + assertEquals(1, ps.executeUpdate()); + ps.close(); + // Need to set a flag so that the method knows there is an extra test. + testingSetDate = true; // Fall through helper dateTest(); + testingSetDate = false; - assertEquals(4, stmt.executeUpdate("DELETE FROM testdate")); + assertEquals(20, stmt.executeUpdate("DELETE FROM testdate")); stmt.close(); } catch (Exception ex) @@ -127,6 +191,122 @@ public class DateTest extends TestCase assertNotNull(d); assertEquals(d, makeDate(2001, 2, 13)); + assertTrue(rs.next()); + d = rs.getDate(1); + assertNotNull(d); + assertEquals(d, makeDate(1950, 4, 2)); + + assertTrue(rs.next()); + d = rs.getDate(1); + assertNotNull(d); + assertEquals(d, makeDate(1970, 11, 30)); + + assertTrue(rs.next()); + d = rs.getDate(1); + assertNotNull(d); + assertEquals(d, makeDate(1988, 1, 1)); + + assertTrue(rs.next()); + d = rs.getDate(1); + assertNotNull(d); + assertEquals(d, makeDate(2003, 7, 9)); + + assertTrue(rs.next()); + d = rs.getDate(1); + assertNotNull(d); + assertEquals(d, makeDate(1934, 2, 28)); + + assertTrue(rs.next()); + d = rs.getDate(1); + assertNotNull(d); + assertEquals(d, makeDate(1969, 4, 3)); + + assertTrue(rs.next()); + d = rs.getDate(1); + assertNotNull(d); + assertEquals(d, makeDate(1982, 8, 3)); + + assertTrue(rs.next()); + d = rs.getDate(1); + assertNotNull(d); + assertEquals(d, makeDate(2012, 3, 15)); + + assertTrue(rs.next()); + d = rs.getDate(1); + assertNotNull(d); + assertEquals(d, makeDate(1912, 5, 1)); + + assertTrue(rs.next()); + d = rs.getDate(1); + assertNotNull(d); + assertEquals(d, makeDate(1971, 12, 15)); + + assertTrue(rs.next()); + d = rs.getDate(1); + assertNotNull(d); + assertEquals(d, makeDate(1984, 12, 3)); + + assertTrue(rs.next()); + d = rs.getDate(1); + assertNotNull(d); + assertEquals(d, makeDate(2000, 1, 1)); + + //now we have to convert the date, cause I fed it a timezone. IF it used it. hence the check + if (testingSetDate) + { + assertTrue(rs.next()); + d = rs.getDate(1); + assertNotNull(d); + java.sql.Date tmpDate = java.sql.Date.valueOf("1944-4-4"); + int localoffset = java.util.Calendar.getInstance().getTimeZone().getRawOffset(); + if (java.util.Calendar.getInstance().getTimeZone().inDaylightTime(tmpDate)) + { + localoffset += 60 * 60 * 1000; + } + int Dateoffset = 60 * 60 * 1000; + tmpDate.setTime(tmpDate.getTime() + Dateoffset + localoffset); + assertEquals(d, makeDate(tmpDate.getYear() + 1900, tmpDate.getMonth()+1, tmpDate.getDate())); + + assertTrue(rs.next()); + d = rs.getDate(1); + assertNotNull(d); + tmpDate = java.sql.Date.valueOf("1970-1-1"); + localoffset = java.util.Calendar.getInstance().getTimeZone().getRawOffset(); + if (java.util.Calendar.getInstance().getTimeZone().inDaylightTime(tmpDate)) + { + localoffset += 60 * 60 * 1000; + } + Dateoffset = 10 * 60 * 60 * 1000; + tmpDate.setTime(tmpDate.getTime() + Dateoffset + localoffset); + assertEquals(d, makeDate(tmpDate.getYear() + 1900, tmpDate.getMonth()+1, tmpDate.getDate())); + + assertTrue(rs.next()); + d = rs.getDate(1); + assertNotNull(d); + tmpDate = java.sql.Date.valueOf("1982-12-14"); + localoffset = java.util.Calendar.getInstance().getTimeZone().getRawOffset(); + if (java.util.Calendar.getInstance().getTimeZone().inDaylightTime(tmpDate)) + { + localoffset += 60 * 60 * 1000; + } + Dateoffset = -13 * 60 * 60 * 1000; + tmpDate.setTime(tmpDate.getTime() + Dateoffset + localoffset); + assertEquals(d, makeDate(tmpDate.getYear() + 1900, tmpDate.getMonth()+1, tmpDate.getDate())); + + assertTrue(rs.next()); + d = rs.getDate(1); + assertNotNull(d); + tmpDate = java.sql.Date.valueOf("2010-08-03"); + localoffset = java.util.Calendar.getInstance().getTimeZone().getRawOffset(); + if (java.util.Calendar.getInstance().getTimeZone().inDaylightTime(tmpDate)) + { + localoffset += 60 * 60 * 1000; + } + Dateoffset = -5 * 60 * 60 * 1000; + tmpDate.setTime(tmpDate.getTime() + Dateoffset + localoffset); + assertEquals(d, makeDate(tmpDate.getYear() + 1900, tmpDate.getMonth()+1, tmpDate.getDate())); + } + assertTrue(!rs.next()); rs.close(); diff --git a/src/interfaces/jdbc/org/postgresql/test/jdbc2/ResultSetTest.java b/src/interfaces/jdbc/org/postgresql/test/jdbc2/ResultSetTest.java index 01ff6203fe..6a1803f4c2 100644 --- a/src/interfaces/jdbc/org/postgresql/test/jdbc2/ResultSetTest.java +++ b/src/interfaces/jdbc/org/postgresql/test/jdbc2/ResultSetTest.java @@ -38,6 +38,35 @@ public class ResultSetTest extends TestCase TestUtil.createTable(con, "testint", "a int"); stmt.executeUpdate("INSERT INTO testint VALUES (12345)"); + + TestUtil.createTable(con, "testbool", "a boolean"); + + TestUtil.createTable(con, "testbit", "a bit"); + + TestUtil.createTable(con, "testboolstring", "a varchar(30)"); + + stmt.executeUpdate("INSERT INTO testboolstring VALUES('true')"); + stmt.executeUpdate("INSERT INTO testboolstring VALUES('false')"); + stmt.executeUpdate("INSERT INTO testboolstring VALUES('t')"); + stmt.executeUpdate("INSERT INTO testboolstring VALUES('f')"); + stmt.executeUpdate("INSERT INTO testboolstring VALUES('1.0')"); + stmt.executeUpdate("INSERT INTO testboolstring VALUES('0.0')"); + stmt.executeUpdate("INSERT INTO testboolstring VALUES('TRUE')"); + stmt.executeUpdate("INSERT INTO testboolstring VALUES('this is not true')"); + + TestUtil.createTable(con, "testnumeric", "a numeric"); + stmt.executeUpdate("INSERT INTO testnumeric VALUES('1.0')"); + stmt.executeUpdate("INSERT INTO testnumeric VALUES('0.0')"); + stmt.executeUpdate("INSERT INTO testnumeric VALUES('-1.0')"); + stmt.executeUpdate("INSERT INTO testnumeric VALUES('1.2')"); + stmt.executeUpdate("INSERT INTO testnumeric VALUES('99999.2')"); + stmt.executeUpdate("INSERT INTO testnumeric VALUES('99999')"); + stmt.executeUpdate("INSERT INTO testnumeric VALUES('-2.5')"); + stmt.executeUpdate("INSERT INTO testnumeric VALUES('-99999.2')"); + stmt.executeUpdate("INSERT INTO testnumeric VALUES('-99999')"); + + stmt.close(); + stmt.close(); } @@ -47,6 +76,10 @@ public class ResultSetTest extends TestCase TestUtil.dropTable(con, "testrs"); TestUtil.dropTable(con, "teststring"); TestUtil.dropTable(con, "testint"); + TestUtil.dropTable(con, "testbool"); + TestUtil.dropTable(con, "testbit"); + TestUtil.dropTable(con, "testboolstring"); + TestUtil.dropTable(con, "testnumeric"); TestUtil.closeDB(con); } @@ -114,4 +147,139 @@ public class ResultSetTest extends TestCase assertEquals(rs.getString(1), "12"); assertEquals(new String(rs.getBytes(1)), "12"); } + + public void booleanTests(boolean useServerPrepare) throws Exception + { + java.sql.PreparedStatement pstmt = con.prepareStatement("insert into testbool values (?)"); + if (useServerPrepare) + ((org.postgresql.PGStatement)pstmt).setUseServerPrepare(true); + + pstmt.setObject(1, new Float(0), java.sql.Types.BIT); + pstmt.executeUpdate(); + + pstmt.setObject(1, new Float(1), java.sql.Types.BIT); + pstmt.executeUpdate(); + + pstmt.setObject(1, "False", java.sql.Types.BIT); + pstmt.executeUpdate(); + + pstmt.setObject(1, "True", java.sql.Types.BIT); + pstmt.executeUpdate(); + + ResultSet rs = con.createStatement().executeQuery("select * from testbool"); + for (int i = 0; i<2; i++) + { + assertTrue(rs.next()); + assertEquals(false, rs.getBoolean(1)); + assertTrue(rs.next()); + assertEquals(true, rs.getBoolean(1)); + } + + pstmt = con.prepareStatement("insert into testbit values (?)"); + + pstmt.setObject(1, new Float(0), java.sql.Types.BIT); + pstmt.executeUpdate(); + + pstmt.setObject(1, new Float(1), java.sql.Types.BIT); + pstmt.executeUpdate(); + + pstmt.setObject(1, "false", java.sql.Types.BIT); + pstmt.executeUpdate(); + + pstmt.setObject(1, "true", java.sql.Types.BIT); + pstmt.executeUpdate(); + + rs = con.createStatement().executeQuery("select * from testbit"); + + for (int i = 0;i<2; i++) + { + assertTrue(rs.next()); + assertEquals(false, rs.getBoolean(1)); + assertTrue(rs.next()); + assertEquals(true, rs.getBoolean(1)); + } + + rs = con.createStatement().executeQuery("select * from testboolstring"); + + for (int i = 0;i<4; i++) + { + assertTrue(rs.next()); + assertEquals(true, rs.getBoolean(1)); + assertTrue(rs.next()); + assertEquals(false, rs.getBoolean(1)); + } + } + + public void testBoolean() throws Exception + { + booleanTests(true); + booleanTests(false); + } + + public void testgetByte() throws Exception + { + ResultSet rs = con.createStatement().executeQuery("select * from testnumeric"); + boolean thrown = false; + + assertTrue(rs.next()); + assertEquals(1,rs.getByte(1)); + + assertTrue(rs.next()); + assertEquals(0,rs.getByte(1)); + + assertTrue(rs.next()); + assertEquals(-1,rs.getByte(1)); + int count = 3; + + while (rs.next()) + { + try + { + rs.getByte(1); + } + catch (Exception e) + { + thrown = true; + } + if (!thrown) + fail("Exception expected."); + count++; + } + if (count != 9) + fail("Exception expected."); + } + + public void testgetShort() throws Exception + { + ResultSet rs = con.createStatement().executeQuery("select * from testnumeric"); + boolean thrown = false; + + assertTrue(rs.next()); + assertEquals(1,rs.getShort(1)); + + assertTrue(rs.next()); + assertEquals(0,rs.getShort(1)); + + assertTrue(rs.next()); + assertEquals(-1,rs.getShort(1)); + int count = 3; + + while (rs.next()) + { + try + { + rs.getShort(1); + } + catch (Exception e) + { + thrown = true; + } + if (!thrown) + fail("Exception expected."); + count++; + } + if (count != 9) + fail("Exception expected."); + } + } diff --git a/src/interfaces/jdbc/org/postgresql/test/jdbc2/TimeTest.java b/src/interfaces/jdbc/org/postgresql/test/jdbc2/TimeTest.java index 9f2dc1600f..c8b3923e56 100644 --- a/src/interfaces/jdbc/org/postgresql/test/jdbc2/TimeTest.java +++ b/src/interfaces/jdbc/org/postgresql/test/jdbc2/TimeTest.java @@ -5,7 +5,7 @@ import junit.framework.TestCase; import java.sql.*; /* - * $Id: TimeTest.java,v 1.5 2002/08/14 20:35:40 barry Exp $ + * $Id: TimeTest.java,v 1.6 2003/09/22 04:55:00 barry Exp $ * * Some simple tests based on problems reported by users. Hopefully these will * help prevent previous problems from re-occuring ;-) @@ -15,6 +15,7 @@ public class TimeTest extends TestCase { private Connection con; + private boolean testSetTime = false; public TimeTest(String name) { @@ -44,11 +45,18 @@ public class TimeTest extends TestCase assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testtime", "'01:02:03'"))); assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testtime", "'23:59:59'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testtime", "'12:00:00'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testtime", "'05:15:21'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testtime", "'16:21:51'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testtime", "'12:15:12'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testtime", "'22:12:01'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testtime", "'08:46:44'"))); + // Fall through helper timeTest(); - assertEquals(2, stmt.executeUpdate("DELETE FROM testtime")); + assertEquals(8, stmt.executeUpdate("DELETE FROM testtime")); stmt.close(); } catch (Exception ex) @@ -72,11 +80,38 @@ public class TimeTest extends TestCase ps.setTime(1, makeTime(23, 59, 59)); assertEquals(1, ps.executeUpdate()); + + ps.setObject(1, java.sql.Time.valueOf("12:00:00"), java.sql.Types.TIME); + assertEquals(1, ps.executeUpdate()); + + ps.setObject(1, java.sql.Time.valueOf("05:15:21"), java.sql.Types.TIME); + assertEquals(1, ps.executeUpdate()); + ps.setObject(1, java.sql.Time.valueOf("16:21:51"), java.sql.Types.TIME); + assertEquals(1, ps.executeUpdate()); + + ps.setObject(1, java.sql.Time.valueOf("12:15:12"), java.sql.Types.TIME); + assertEquals(1, ps.executeUpdate()); + + ps.setObject(1, "22:12:1", java.sql.Types.TIME); + assertEquals(1, ps.executeUpdate()); + + ps.setObject(1, "8:46:44", java.sql.Types.TIME); + assertEquals(1, ps.executeUpdate()); + + ps.setObject(1, "5:1:2-03", java.sql.Types.TIME); + assertEquals(1, ps.executeUpdate()); + + ps.setObject(1, "23:59:59+11", java.sql.Types.TIME); + assertEquals(1, ps.executeUpdate()); + + // Need to let the test know this one has extra test cases. + testSetTime = true; // Fall through helper timeTest(); + testSetTime = false; - assertEquals(2, stmt.executeUpdate("DELETE FROM testtime")); + assertEquals(10, stmt.executeUpdate("DELETE FROM testtime")); stmt.close(); ps.close(); } @@ -108,6 +143,66 @@ public class TimeTest extends TestCase assertNotNull(t); assertEquals(makeTime(23, 59, 59), t); + assertTrue(rs.next()); + t = rs.getTime(1); + assertNotNull(t); + assertEquals(makeTime(12, 0, 0), t); + + assertTrue(rs.next()); + t = rs.getTime(1); + assertNotNull(t); + assertEquals(makeTime(5, 15, 21), t); + + assertTrue(rs.next()); + t = rs.getTime(1); + assertNotNull(t); + assertEquals(makeTime(16, 21, 51), t); + + assertTrue(rs.next()); + t = rs.getTime(1); + assertNotNull(t); + assertEquals(makeTime(12, 15, 12), t); + + assertTrue(rs.next()); + t = rs.getTime(1); + assertNotNull(t); + assertEquals(makeTime(22, 12, 1), t); + + assertTrue(rs.next()); + t = rs.getTime(1); + assertNotNull(t); + assertEquals(makeTime(8, 46, 44), t); + + // If we're checking for timezones. + if (testSetTime) + { + assertTrue(rs.next()); + t = rs.getTime(1); + assertNotNull(t); + java.sql.Time tmpTime = java.sql.Time.valueOf("5:1:2"); + int localoffset = java.util.Calendar.getInstance().getTimeZone().getRawOffset(); + if (java.util.Calendar.getInstance().getTimeZone().inDaylightTime(tmpTime)) + { + localoffset += 60 * 60 * 1000; + } + int Timeoffset = 3 * 60 * 60 * 1000; + tmpTime.setTime(tmpTime.getTime() + Timeoffset + localoffset); + assertEquals(t, makeTime(tmpTime.getHours(), tmpTime.getMinutes(), tmpTime.getSeconds())); + + assertTrue(rs.next()); + t = rs.getTime(1); + assertNotNull(t); + tmpTime= java.sql.Time.valueOf("23:59:59"); + localoffset = java.util.Calendar.getInstance().getTimeZone().getRawOffset(); + if (java.util.Calendar.getInstance().getTimeZone().inDaylightTime(tmpTime)) + { + localoffset += 60 * 60 * 1000; + } + Timeoffset = -11 * 60 * 60 * 1000; + tmpTime.setTime(tmpTime.getTime() + Timeoffset + localoffset); + assertEquals(t, makeTime(tmpTime.getHours(), tmpTime.getMinutes(), tmpTime.getSeconds())); + } + assertTrue(! rs.next()); rs.close(); diff --git a/src/interfaces/jdbc/org/postgresql/test/jdbc2/TimestampTest.java b/src/interfaces/jdbc/org/postgresql/test/jdbc2/TimestampTest.java index c0a43cdefb..e66dc1025c 100644 --- a/src/interfaces/jdbc/org/postgresql/test/jdbc2/TimestampTest.java +++ b/src/interfaces/jdbc/org/postgresql/test/jdbc2/TimestampTest.java @@ -5,7 +5,7 @@ import junit.framework.TestCase; import java.sql.*; /* - * $Id: TimestampTest.java,v 1.11 2003/05/29 04:39:48 barry Exp $ + * $Id: TimestampTest.java,v 1.12 2003/09/22 04:55:00 barry Exp $ * * Test get/setTimestamp for both timestamp with time zone and * timestamp without time zone datatypes @@ -51,11 +51,28 @@ public class TimestampTest extends TestCase assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + TS2WTZ_PGFORMAT + "'"))); assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + TS3WTZ_PGFORMAT + "'"))); assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + TS4WTZ_PGFORMAT + "'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + TS1WTZ_PGFORMAT + "'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + TS2WTZ_PGFORMAT + "'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + TS3WTZ_PGFORMAT + "'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + TS4WTZ_PGFORMAT + "'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + TS1WTZ_PGFORMAT + "'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + TS2WTZ_PGFORMAT + "'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + TS3WTZ_PGFORMAT + "'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + TS4WTZ_PGFORMAT + "'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + new java.sql.Timestamp(tmpDate1.getTime()) + "'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + new java.sql.Timestamp(tmpDate2.getTime()) + "'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + new java.sql.Timestamp(tmpDate3.getTime()) + "'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + new java.sql.Timestamp(tmpDate4.getTime()) + "'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + new java.sql.Timestamp(tmpTime1.getTime()) + "'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + new java.sql.Timestamp(tmpTime2.getTime()) + "'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + new java.sql.Timestamp(tmpTime3.getTime()) + "'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + new java.sql.Timestamp(tmpTime4.getTime()) + "'"))); + // Fall through helper timestampTestWTZ(); - assertEquals(4, stmt.executeUpdate("DELETE FROM " + TSWTZ_TABLE)); + assertEquals(20, stmt.executeUpdate("DELETE FROM " + TSWTZ_TABLE)); stmt.close(); } @@ -89,11 +106,51 @@ public class TimestampTest extends TestCase pstmt.setTimestamp(1, TS4WTZ); assertEquals(1, pstmt.executeUpdate()); + + // With java.sql.Timestamp + pstmt.setObject(1,TS1WTZ, java.sql.Types.TIMESTAMP); + assertEquals(1, pstmt.executeUpdate()); + pstmt.setObject(1,TS2WTZ, java.sql.Types.TIMESTAMP); + assertEquals(1, pstmt.executeUpdate()); + pstmt.setObject(1,TS3WTZ, java.sql.Types.TIMESTAMP); + assertEquals(1, pstmt.executeUpdate()); + pstmt.setObject(1,TS4WTZ, java.sql.Types.TIMESTAMP); + assertEquals(1, pstmt.executeUpdate()); + + // With Strings + pstmt.setObject(1,TS1WTZ_PGFORMAT, java.sql.Types.TIMESTAMP); + assertEquals(1, pstmt.executeUpdate()); + pstmt.setObject(1,TS2WTZ_PGFORMAT, java.sql.Types.TIMESTAMP); + assertEquals(1, pstmt.executeUpdate()); + pstmt.setObject(1,TS3WTZ_PGFORMAT, java.sql.Types.TIMESTAMP); + assertEquals(1, pstmt.executeUpdate()); + pstmt.setObject(1,TS4WTZ_PGFORMAT, java.sql.Types.TIMESTAMP); + assertEquals(1, pstmt.executeUpdate()); + // With java.sql.Date + pstmt.setObject(1,tmpDate1, java.sql.Types.TIMESTAMP); + assertEquals(1, pstmt.executeUpdate()); + pstmt.setObject(1,tmpDate2, java.sql.Types.TIMESTAMP); + assertEquals(1, pstmt.executeUpdate()); + pstmt.setObject(1,tmpDate3, java.sql.Types.TIMESTAMP); + assertEquals(1, pstmt.executeUpdate()); + pstmt.setObject(1,tmpDate4, java.sql.Types.TIMESTAMP); + assertEquals(1, pstmt.executeUpdate()); + + // With java.sql.Time + pstmt.setObject(1,tmpTime1, java.sql.Types.TIMESTAMP); + assertEquals(1, pstmt.executeUpdate()); + pstmt.setObject(1,tmpTime2, java.sql.Types.TIMESTAMP); + assertEquals(1, pstmt.executeUpdate()); + pstmt.setObject(1,tmpTime3, java.sql.Types.TIMESTAMP); + assertEquals(1, pstmt.executeUpdate()); + pstmt.setObject(1,tmpTime4, java.sql.Types.TIMESTAMP); + assertEquals(1, pstmt.executeUpdate()); + // Fall through helper timestampTestWTZ(); - assertEquals(4, stmt.executeUpdate("DELETE FROM " + TSWTZ_TABLE)); + assertEquals(20, stmt.executeUpdate("DELETE FROM " + TSWTZ_TABLE)); pstmt.close(); stmt.close(); @@ -120,11 +177,27 @@ public class TimestampTest extends TestCase assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS2WOTZ_PGFORMAT + "'"))); assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS3WOTZ_PGFORMAT + "'"))); assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS4WOTZ_PGFORMAT + "'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS1WOTZ_PGFORMAT + "'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS2WOTZ_PGFORMAT + "'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS3WOTZ_PGFORMAT + "'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS4WOTZ_PGFORMAT + "'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS1WOTZ_PGFORMAT + "'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS2WOTZ_PGFORMAT + "'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS3WOTZ_PGFORMAT + "'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS4WOTZ_PGFORMAT + "'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + new java.sql.Timestamp(tmpDate1WOTZ.getTime()) + "'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + new java.sql.Timestamp(tmpDate2WOTZ.getTime()) + "'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + new java.sql.Timestamp(tmpDate3WOTZ.getTime()) + "'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + new java.sql.Timestamp(tmpDate4WOTZ.getTime()) + "'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + new java.sql.Timestamp(tmpTime1WOTZ.getTime()) + "'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + new java.sql.Timestamp(tmpTime2WOTZ.getTime()) + "'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + new java.sql.Timestamp(tmpTime3WOTZ.getTime()) + "'"))); + assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + new java.sql.Timestamp(tmpTime4WOTZ.getTime()) + "'"))); // Fall through helper timestampTestWOTZ(); - assertEquals(4, stmt.executeUpdate("DELETE FROM " + TSWOTZ_TABLE)); + assertEquals(20, stmt.executeUpdate("DELETE FROM " + TSWOTZ_TABLE)); stmt.close(); } @@ -160,10 +233,51 @@ public class TimestampTest extends TestCase pstmt.setTimestamp(1, TS4WOTZ); assertEquals(1, pstmt.executeUpdate()); + + // With java.sql.Timestamp + pstmt.setObject(1,TS1WOTZ, java.sql.Types.TIMESTAMP); + assertEquals(1, pstmt.executeUpdate()); + pstmt.setObject(1,TS2WOTZ, java.sql.Types.TIMESTAMP); + assertEquals(1, pstmt.executeUpdate()); + pstmt.setObject(1,TS3WOTZ, java.sql.Types.TIMESTAMP); + assertEquals(1, pstmt.executeUpdate()); + pstmt.setObject(1,TS4WOTZ, java.sql.Types.TIMESTAMP); + assertEquals(1, pstmt.executeUpdate()); + + // With Strings + pstmt.setObject(1,TS1WOTZ_PGFORMAT, java.sql.Types.TIMESTAMP); + assertEquals(1, pstmt.executeUpdate()); + pstmt.setObject(1,TS2WOTZ_PGFORMAT, java.sql.Types.TIMESTAMP); + assertEquals(1, pstmt.executeUpdate()); + pstmt.setObject(1,TS3WOTZ_PGFORMAT, java.sql.Types.TIMESTAMP); + assertEquals(1, pstmt.executeUpdate()); + pstmt.setObject(1,TS4WOTZ_PGFORMAT, java.sql.Types.TIMESTAMP); + assertEquals(1, pstmt.executeUpdate()); + + // With java.sql.Date + pstmt.setObject(1,tmpDate1WOTZ, java.sql.Types.TIMESTAMP); + assertEquals(1, pstmt.executeUpdate()); + pstmt.setObject(1,tmpDate2WOTZ, java.sql.Types.TIMESTAMP); + assertEquals(1, pstmt.executeUpdate()); + pstmt.setObject(1,tmpDate3WOTZ, java.sql.Types.TIMESTAMP); + assertEquals(1, pstmt.executeUpdate()); + pstmt.setObject(1,tmpDate4WOTZ, java.sql.Types.TIMESTAMP); + assertEquals(1, pstmt.executeUpdate()); + + // With java.sql.Time + pstmt.setObject(1,tmpTime1WOTZ, java.sql.Types.TIMESTAMP); + assertEquals(1, pstmt.executeUpdate()); + pstmt.setObject(1,tmpTime2WOTZ, java.sql.Types.TIMESTAMP); + assertEquals(1, pstmt.executeUpdate()); + pstmt.setObject(1,tmpTime3WOTZ, java.sql.Types.TIMESTAMP); + assertEquals(1, pstmt.executeUpdate()); + pstmt.setObject(1,tmpTime4WOTZ, java.sql.Types.TIMESTAMP); + assertEquals(1, pstmt.executeUpdate()); + // Fall through helper timestampTestWOTZ(); - assertEquals(4, stmt.executeUpdate("DELETE FROM " + TSWOTZ_TABLE)); + assertEquals(20, stmt.executeUpdate("DELETE FROM " + TSWOTZ_TABLE)); pstmt.close(); stmt.close(); @@ -183,28 +297,73 @@ public class TimestampTest extends TestCase ResultSet rs; java.sql.Timestamp t; - rs = stmt.executeQuery("select ts from " + TSWTZ_TABLE + " order by ts"); + rs = stmt.executeQuery("select ts from " + TSWTZ_TABLE); //removed the order by ts assertNotNull(rs); + for (int i=0; i<3; i++) + { + assertTrue(rs.next()); + t = rs.getTimestamp(1); + assertNotNull(t); + assertTrue(t.equals(TS1WTZ)); + + assertTrue(rs.next()); + t = rs.getTimestamp(1); + assertNotNull(t); + assertTrue(t.equals(TS2WTZ)); + + assertTrue(rs.next()); + t = rs.getTimestamp(1); + assertNotNull(t); + assertTrue(t.equals(TS3WTZ)); + + assertTrue(rs.next()); + t = rs.getTimestamp(1); + assertNotNull(t); + assertTrue(t.equals(TS4WTZ)); + } + + // Testing for Date assertTrue(rs.next()); t = rs.getTimestamp(1); assertNotNull(t); - assertTrue(t.equals(TS1WTZ)); + assertEquals(t.getTime(), tmpDate1.getTime()); assertTrue(rs.next()); t = rs.getTimestamp(1); assertNotNull(t); - assertTrue(t.equals(TS2WTZ)); + assertEquals(t.getTime(), tmpDate2.getTime()); assertTrue(rs.next()); t = rs.getTimestamp(1); assertNotNull(t); - assertTrue(t.equals(TS3WTZ)); + assertEquals(t.getTime(), tmpDate3.getTime()); assertTrue(rs.next()); t = rs.getTimestamp(1); assertNotNull(t); - assertTrue(t.equals(TS4WTZ)); + assertEquals(t.getTime(), tmpDate4.getTime()); + + // Testing for Time + assertTrue(rs.next()); + t = rs.getTimestamp(1); + assertNotNull(t); + assertEquals(t.getTime(), tmpTime1.getTime()); + + assertTrue(rs.next()); + t = rs.getTimestamp(1); + assertNotNull(t); + assertEquals(t.getTime(), tmpTime2.getTime()); + + assertTrue(rs.next()); + t = rs.getTimestamp(1); + assertNotNull(t); + assertEquals(t.getTime(), tmpTime3.getTime()); + + assertTrue(rs.next()); + t = rs.getTimestamp(1); + assertNotNull(t); + assertEquals(t.getTime(), tmpTime4.getTime()); assertTrue(! rs.next()); // end of table. Fail if more entries exist. @@ -221,29 +380,74 @@ public class TimestampTest extends TestCase ResultSet rs; java.sql.Timestamp t; - rs = stmt.executeQuery("select ts from " + TSWOTZ_TABLE + " order by ts"); + rs = stmt.executeQuery("select ts from " + TSWOTZ_TABLE); //removed the order by ts assertNotNull(rs); + for (int i=0; i<3; i++) + { + assertTrue(rs.next()); + t = rs.getTimestamp(1); + assertNotNull(t); + assertTrue(t.equals(TS1WOTZ)); + + assertTrue(rs.next()); + t = rs.getTimestamp(1); + assertNotNull(t); + assertTrue(t.equals(TS2WOTZ)); + + assertTrue(rs.next()); + t = rs.getTimestamp(1); + assertNotNull(t); + assertTrue(t.equals(TS3WOTZ)); + + assertTrue(rs.next()); + t = rs.getTimestamp(1); + assertNotNull(t); + assertTrue(t.equals(TS4WOTZ)); + } + + // Testing for Date assertTrue(rs.next()); t = rs.getTimestamp(1); assertNotNull(t); - assertTrue(t.equals(TS1WOTZ)); + assertEquals(t.getTime(), tmpDate1WOTZ.getTime()); assertTrue(rs.next()); t = rs.getTimestamp(1); assertNotNull(t); - assertTrue(t.equals(TS2WOTZ)); + assertEquals(t.getTime(), tmpDate2WOTZ.getTime()); assertTrue(rs.next()); t = rs.getTimestamp(1); assertNotNull(t); - assertTrue(t.equals(TS3WOTZ)); + assertEquals(t.getTime(), tmpDate3WOTZ.getTime()); assertTrue(rs.next()); t = rs.getTimestamp(1); assertNotNull(t); - assertTrue(t.equals(TS4WOTZ)); + assertEquals(t.getTime(), tmpDate4WOTZ.getTime()); + + // Testing for Time + assertTrue(rs.next()); + t = rs.getTimestamp(1); + assertNotNull(t); + assertEquals(t.getTime(), tmpTime1WOTZ.getTime()); + assertTrue(rs.next()); + t = rs.getTimestamp(1); + assertNotNull(t); + assertEquals(t.getTime(), tmpTime2WOTZ.getTime()); + + assertTrue(rs.next()); + t = rs.getTimestamp(1); + assertNotNull(t); + assertEquals(t.getTime(), tmpTime3WOTZ.getTime()); + + assertTrue(rs.next()); + t = rs.getTimestamp(1); + assertNotNull(t); + assertEquals(t.getTime(), tmpTime4WOTZ.getTime()); + assertTrue(! rs.next()); // end of table. Fail if more entries exist. rs.close(); @@ -311,5 +515,24 @@ public class TimestampTest extends TestCase private static final String TSWTZ_TABLE = "testtimestampwtz"; private static final String TSWOTZ_TABLE = "testtimestampwotz"; + + private static final java.sql.Date tmpDate1 = new java.sql.Date(TS1WTZ.getTime()); + private static final java.sql.Time tmpTime1 = new java.sql.Time(TS1WTZ.getTime()); + private static final java.sql.Date tmpDate2 = new java.sql.Date(TS2WTZ.getTime()); + private static final java.sql.Time tmpTime2 = new java.sql.Time(TS2WTZ.getTime()); + private static final java.sql.Date tmpDate3 = new java.sql.Date(TS3WTZ.getTime()); + private static final java.sql.Time tmpTime3 = new java.sql.Time(TS3WTZ.getTime()); + private static final java.sql.Date tmpDate4 = new java.sql.Date(TS4WTZ.getTime()); + private static final java.sql.Time tmpTime4 = new java.sql.Time(TS4WTZ.getTime()); + + private static final java.sql.Date tmpDate1WOTZ = new java.sql.Date(TS1WOTZ.getTime()); + private static final java.sql.Time tmpTime1WOTZ = new java.sql.Time(TS1WOTZ.getTime()); + private static final java.sql.Date tmpDate2WOTZ = new java.sql.Date(TS2WOTZ.getTime()); + private static final java.sql.Time tmpTime2WOTZ = new java.sql.Time(TS2WOTZ.getTime()); + private static final java.sql.Date tmpDate3WOTZ = new java.sql.Date(TS3WOTZ.getTime()); + private static final java.sql.Time tmpTime3WOTZ = new java.sql.Time(TS3WOTZ.getTime()); + private static final java.sql.Date tmpDate4WOTZ = new java.sql.Date(TS4WOTZ.getTime()); + private static final java.sql.Time tmpTime4WOTZ = new java.sql.Time(TS4WOTZ.getTime()); + }