Format timestamps without fractional seconds correctly

h2/src/main/org/h2/util/DateTimeUtils.java

@@ -1346,10 +1346,8 @@ public class DateTimeUtils {
      *
      * @param buff the target string builder
      * @param nanos the time in nanoseconds
-     * @param alwaysAddMillis whether to always add at least ".0"
      */
-    public static void appendTime(StringBuilder buff, long nanos,
-            boolean alwaysAddMillis) {
+    public static void appendTime(StringBuilder buff, long nanos) {
         if (nanos < 0) {
             buff.append('-');
             nanos = -nanos;
@@ -1373,7 +1371,7 @@ public class DateTimeUtils {
         StringUtils.appendZeroPadded(buff, 2, m);
         buff.append(':');
         StringUtils.appendZeroPadded(buff, 2, s);
-        if (alwaysAddMillis || ms > 0 || nanos > 0) {
+        if (ms > 0 || nanos > 0) {
             buff.append('.');
             int start = buff.length();
             StringUtils.appendZeroPadded(buff, 3, ms);
@@ -1424,7 +1422,7 @@ public class DateTimeUtils {
         StringBuilder buff = new StringBuilder(ValueTimestampTimeZone.MAXIMUM_PRECISION);
         appendDate(buff, dateValue);
         buff.append(' ');
-        appendTime(buff, timeNanos, true);
+        appendTime(buff, timeNanos);
         appendTimeZone(buff, timeZoneOffsetMins);
         return buff.toString();
     }

h2/src/main/org/h2/value/ValueTime.java

@@ -72,7 +72,7 @@ public class ValueTime extends Value {
         if (!SysProperties.UNLIMITED_TIME_RANGE) {
             if (nanos < 0L || nanos >= 86400000000000L) {
                 StringBuilder builder = new StringBuilder();
-                DateTimeUtils.appendTime(builder, nanos, false);
+                DateTimeUtils.appendTime(builder, nanos);
                 throw DbException.get(ErrorCode.INVALID_DATETIME_CONSTANT_2,
                         "TIME", builder.toString());
             }
@@ -136,7 +136,7 @@ public class ValueTime extends Value {
     @Override
     public String getString() {
         StringBuilder buff = new StringBuilder(MAXIMUM_PRECISION);
-        DateTimeUtils.appendTime(buff, nanos, false);
+        DateTimeUtils.appendTime(buff, nanos);
         return buff.toString();
     }
 

h2/src/main/org/h2/value/ValueTimestamp.java

@@ -183,7 +183,7 @@ public class ValueTimestamp extends Value {
         StringBuilder buff = new StringBuilder(MAXIMUM_PRECISION);
         DateTimeUtils.appendDate(buff, dateValue);
         buff.append(' ');
-        DateTimeUtils.appendTime(buff, timeNanos, true);
+        DateTimeUtils.appendTime(buff, timeNanos);
         return buff.toString();
     }
 

h2/src/test/org/h2/test/db/TestDateStorage.java

@@ -84,26 +84,26 @@ public class TestDateStorage extends TestBase {
             prep.execute();
             rs = stat.executeQuery("select * from ts order by x");
             rs.next();
-            assertEquals("2010-03-14 02:15:00.0",
+            assertEquals("2010-03-14 02:15:00",
                     rs.getString(1));
             assertEquals("2010-03-13 18:15:00.0",
                     rs.getTimestamp(1, utcCalendar).toString());
             assertEquals("2010-03-14 03:15:00.0",
                     rs.getTimestamp(1).toString());
-            assertEquals("2010-03-14 02:15:00.0",
+            assertEquals("2010-03-14 02:15:00",
                     rs.getString("x"));
             assertEquals("2010-03-13 18:15:00.0",
                     rs.getTimestamp("x", utcCalendar).toString());
             assertEquals("2010-03-14 03:15:00.0",
                     rs.getTimestamp("x").toString());
             rs.next();
-            assertEquals("2010-03-14 03:15:00.0",
+            assertEquals("2010-03-14 03:15:00",
                     rs.getString(1));
             assertEquals("2010-03-13 19:15:00.0",
                     rs.getTimestamp(1, utcCalendar).toString());
             assertEquals("2010-03-14 03:15:00.0",
                     rs.getTimestamp(1).toString());
-            assertEquals("2010-03-14 03:15:00.0",
+            assertEquals("2010-03-14 03:15:00",
                     rs.getString("x"));
             assertEquals("2010-03-13 19:15:00.0",
                     rs.getTimestamp("x", utcCalendar).toString());

h2/src/test/org/h2/test/db/TestFunctions.java

@@ -328,7 +328,7 @@ public class TestFunctions extends TestBase implements AggregateFunction {
         rs = stat.executeQuery(
                 "call TO_CHAR_2(TIMESTAMP '2001-02-03 04:05:06', 'format')");
         rs.next();
-        assertEquals("2001-02-03 04:05:06.0", rs.getString(1));
+        assertEquals("2001-02-03 04:05:06", rs.getString(1));
         stat.execute("drop alias TO_CHAR_2");
         conn.close();
     }

h2/src/test/org/h2/test/jdbc/TestResultSet.java

@@ -1262,13 +1262,13 @@ public class TestResultSet extends TestBase {
         assertEquals("99999-12-23", rs.getString(1));
         rs = stat.executeQuery("call timestamp '99999-12-23 01:02:03.000'");
         rs.next();
-        assertEquals("99999-12-23 01:02:03.0", rs.getString(1));
+        assertEquals("99999-12-23 01:02:03", rs.getString(1));
         rs = stat.executeQuery("call date '-99999-12-23'");
         rs.next();
         assertEquals("-99999-12-23", rs.getString(1));
         rs = stat.executeQuery("call timestamp '-99999-12-23 01:02:03.000'");
         rs.next();
-        assertEquals("-99999-12-23 01:02:03.0", rs.getString(1));
+        assertEquals("-99999-12-23 01:02:03", rs.getString(1));
 
         stat.execute("CREATE TABLE TEST(ID INT PRIMARY KEY,VALUE DATETIME)");
         stat.execute("INSERT INTO TEST VALUES(1,DATE '2011-11-11')");

h2/src/test/org/h2/test/scripts/datatypes/timestamp-with-timezone.sql

@@ -11,8 +11,8 @@ INSERT INTO tab_with_timezone(x) VALUES ('2017-01-01');
 
 SELECT "Query".* FROM (select * from tab_with_timezone where x > '2016-01-01') AS "Query";
 > X
-> ------------------------
-> 2017-01-01 00:00:00.0+00
+> ----------------------
+> 2017-01-01 00:00:00+00
 
 DELETE FROM tab_with_timezone;
 > update count: 1
@@ -22,9 +22,9 @@ INSERT INTO tab_with_timezone VALUES ('2018-03-25 01:59:00 Europe/Berlin'), ('20
 
 SELECT * FROM tab_with_timezone ORDER BY X;
 > X
-> ------------------------
-> 2018-03-25 01:59:00.0+01
-> 2018-03-25 03:00:00.0+02
+> ----------------------
+> 2018-03-25 01:59:00+01
+> 2018-03-25 03:00:00+02
 > rows (ordered): 2
 
 SELECT TIMESTAMP WITH TIME ZONE '2000-01-10 00:00:00 -02' AS A,
@@ -32,8 +32,8 @@ SELECT TIMESTAMP WITH TIME ZONE '2000-01-10 00:00:00 -02' AS A,
     TIMESTAMP WITH TIME ZONE '2000-01-10 00:00:00.000000000+02:00' AS C,
     TIMESTAMP WITH TIME ZONE '2000-01-10T00:00:00.000000000+09:00[Asia/Tokyo]' AS D;
 > A                      B                      C                      D
-> ------------------------ ------------------------ ------------------------ ------------------------
-> 2000-01-10 00:00:00.0-02 2000-01-10 00:00:00.0+02 2000-01-10 00:00:00.0+02 2000-01-10 00:00:00.0+09
+> ---------------------- ---------------------- ---------------------- ----------------------
+> 2000-01-10 00:00:00-02 2000-01-10 00:00:00+02 2000-01-10 00:00:00+02 2000-01-10 00:00:00+09
 > rows: 1
 
 CREATE TABLE TEST(T1 TIMESTAMP WITH TIME ZONE, T2 TIMESTAMP(0) WITH TIME ZONE, T3 TIMESTAMP(9) WITH TIME ZONE);
@@ -68,8 +68,8 @@ INSERT INTO TEST VALUES ('2000-01-01 08:00:00.123456789Z', '2000-01-01 08:00:00.
 
 SELECT T, T0, T1, T2 FROM TEST;
 > T                             T0                     T1                       T2
-> ----------------------------- ------------------------ ------------------------ -------------------------
-> 2000-01-01 08:00:00.123457+00 2000-01-01 08:00:00.0+00 2000-01-01 08:00:00.1+00 2000-01-01 08:00:00.12+00
+> ----------------------------- ---------------------- ------------------------ -------------------------
+> 2000-01-01 08:00:00.123457+00 2000-01-01 08:00:00+00 2000-01-01 08:00:00.1+00 2000-01-01 08:00:00.12+00
 > rows: 1
 
 SELECT T3, T4, T5, T6 FROM TEST;
@@ -92,8 +92,8 @@ INSERT INTO TEST(T0) VALUES ('2000-01-01 23:59:59.999999999Z');
 
 SELECT T0 FROM TEST;
 > T0
-> ------------------------
-> 2000-01-02 00:00:00.0+00
+> ----------------------
+> 2000-01-02 00:00:00+00
 
 DROP TABLE TEST;
 > ok

h2/src/test/org/h2/test/scripts/datatypes/timestamp.sql

@@ -11,8 +11,8 @@ INSERT INTO TEST(T1, T2) VALUES (TIMESTAMP '2010-01-01 10:00:00', TIMESTAMP WITH
 
 SELECT T1, T2, T1 = T2 FROM TEST;
 > T1                  T2                  T1 = T2
-> --------------------- --------------------- -------
-> 2010-01-01 10:00:00.0 2010-01-01 10:00:00.0 TRUE
+> ------------------- ------------------- -------
+> 2010-01-01 10:00:00 2010-01-01 10:00:00 TRUE
 > rows: 1
 
 ALTER TABLE TEST ADD (T3 TIMESTAMP(0), T4 TIMESTAMP(9) WITHOUT TIME ZONE);
@@ -42,8 +42,8 @@ INSERT INTO TEST VALUES (TIMESTAMP '1999-12-31 08:00:00');
 
 SELECT TIMESTAMP FROM TEST;
 > TIMESTAMP
-> ---------------------
-> 1999-12-31 08:00:00.0
+> -------------------
+> 1999-12-31 08:00:00
 > rows: 1
 
 DROP TABLE TEST;
@@ -61,8 +61,8 @@ INSERT INTO TEST VALUES ('2000-01-01 08:00:00.123456789', '2000-01-01 08:00:00.1
 
 SELECT T, T0, T1, T2 FROM TEST;
 > T                          T0                  T1                    T2
-> -------------------------- --------------------- --------------------- ----------------------
-> 2000-01-01 08:00:00.123457 2000-01-01 08:00:00.0 2000-01-01 08:00:00.1 2000-01-01 08:00:00.12
+> -------------------------- ------------------- --------------------- ----------------------
+> 2000-01-01 08:00:00.123457 2000-01-01 08:00:00 2000-01-01 08:00:00.1 2000-01-01 08:00:00.12
 > rows: 1
 
 SELECT T3, T4, T5, T6 FROM TEST;
@@ -85,8 +85,8 @@ INSERT INTO TEST(T0) VALUES ('2000-01-01 23:59:59.999999999');
 
 SELECT T0 FROM TEST;
 > T0
-> ---------------------
-> 2000-01-02 00:00:00.0
+> -------------------
+> 2000-01-02 00:00:00
 
 DROP TABLE TEST;
 > ok

h2/src/test/org/h2/test/scripts/functions/aggregate/median.sql

@@ -560,29 +560,29 @@ insert into test values ('2000-01-20 20:00:00'), ('2000-01-20 20:00:00'), ('2000
 
 select median(v) from test;
 > MEDIAN(V)
-> ---------------------
-> 2000-01-20 20:00:00.0
+> -------------------
+> 2000-01-20 20:00:00
 
 insert into test values (null);
 > update count: 1
 
 select median(v) from test;
 > MEDIAN(V)
-> ---------------------
-> 2000-01-20 20:00:00.0
+> -------------------
+> 2000-01-20 20:00:00
 
 select median(distinct v) from test;
 > MEDIAN(DISTINCT V)
-> ---------------------
-> 2000-01-15 15:00:00.0
+> -------------------
+> 2000-01-15 15:00:00
 
 insert into test values ('2000-01-10 10:00:00');
 > update count: 1
 
 select median(v) from test;
 > MEDIAN(V)
-> ---------------------
-> 2000-01-15 15:00:00.0
+> -------------------
+> 2000-01-15 15:00:00
 
 delete from test;
 > update count: 5
@@ -592,8 +592,8 @@ insert into test values ('2000-01-20 20:00:00'), ('2000-01-21 20:00:00');
 
 select median(v) from test;
 > MEDIAN(V)
-> ---------------------
-> 2000-01-21 08:00:00.0
+> -------------------
+> 2000-01-21 08:00:00
 
 drop table test;
 > ok
@@ -606,29 +606,29 @@ insert into test values ('2000-01-20 20:00:00+04'), ('2000-01-20 20:00:00+04'),
 
 select median(v) from test;
 > MEDIAN(V)
-> ------------------------
-> 2000-01-20 20:00:00.0+04
+> ----------------------
+> 2000-01-20 20:00:00+04
 
 insert into test values (null);
 > update count: 1
 
 select median(v) from test;
 > MEDIAN(V)
-> ------------------------
-> 2000-01-20 20:00:00.0+04
+> ----------------------
+> 2000-01-20 20:00:00+04
 
 select median(distinct v) from test;
 > MEDIAN(DISTINCT V)
-> ------------------------
-> 2000-01-15 15:00:00.0+03
+> ----------------------
+> 2000-01-15 15:00:00+03
 
 insert into test values ('2000-01-10 10:00:00+02');
 > update count: 1
 
 select median(v) from test;
 > MEDIAN(V)
-> ------------------------
-> 2000-01-15 15:00:00.0+03
+> ----------------------
+> 2000-01-15 15:00:00+03
 
 delete from test;
 > update count: 5
@@ -638,8 +638,8 @@ insert into test values ('2000-01-20 20:00:00+10:15'), ('2000-01-21 20:00:00-09'
 
 select median(v) from test;
 > MEDIAN(V)
-> ---------------------------
-> 2000-01-21 08:00:30.0+00:37
+> -------------------------
+> 2000-01-21 08:00:30+00:37
 
 drop table test;
 > ok

h2/src/test/org/h2/test/scripts/functions/timeanddate/add_months.sql

@@ -6,22 +6,22 @@
 -- 01-Aug-03 + 3 months = 01-Nov-03
 SELECT ADD_MONTHS('2003-08-01', 3) AS R;
 > R
-> ---------------------
-> 2003-11-01 00:00:00.0
+> -------------------
+> 2003-11-01 00:00:00
 > rows: 1
 
 -- 31-Jan-03 + 1 month = 28-Feb-2003
 SELECT ADD_MONTHS('2003-01-31', 1) AS R;
 > R
-> ---------------------
-> 2003-02-28 00:00:00.0
+> -------------------
+> 2003-02-28 00:00:00
 > rows: 1
 
 -- 21-Aug-2003 - 3 months = 21-May-2003
 SELECT ADD_MONTHS('2003-08-21', -3) AS R;
 > R
-> ---------------------
-> 2003-05-21 00:00:00.0
+> -------------------
+> 2003-05-21 00:00:00
 > rows: 1
 
 -- 21-Aug-2003 00:00:00.333 - 3 months = 21-May-2003 00:00:00.333

h2/src/test/org/h2/test/scripts/functions/timeanddate/current-time.sql

@@ -16,8 +16,8 @@ select length(curtime())>=8 c1, length(current_time())>=8 c2, substring(curtime(
 > rows: 1
 
 
-select length(now())>20 c1, length(current_timestamp())>20 c2, length(now(0))>20 c3, length(now(2))>20 c4, substring(now(5), 20, 1) c5 from test;
-> C1   C2   C3   C4   C5
-> ---- ---- ---- ---- --
-> TRUE TRUE TRUE TRUE .
+select length(now())>20 c1, length(current_timestamp())>18 c2, length(now(0))>18 c3, length(now(2))>18 c4 from test;
+> C1   C2   C3   C4
+> ---- ---- ---- ----
+> TRUE TRUE TRUE TRUE
 > rows: 1

h2/src/test/org/h2/test/scripts/functions/timeanddate/dateadd.sql

@@ -32,68 +32,68 @@ insert into test values(date '2001-01-01', time '01:00:00', timestamp '2010-01-0
 
 select ts + t x from test;
 > X
-> ---------------------
-> 2010-01-01 01:00:00.0
+> -------------------
+> 2010-01-01 01:00:00
 > rows: 1
 
 select ts + t + t - t x from test;
 > X
-> ---------------------
-> 2010-01-01 01:00:00.0
+> -------------------
+> 2010-01-01 01:00:00
 > rows: 1
 
 select ts + t * 0.5 x from test;
 > X
-> ---------------------
-> 2010-01-01 00:30:00.0
+> -------------------
+> 2010-01-01 00:30:00
 > rows: 1
 
 select ts + 0.5 x from test;
 > X
-> ---------------------
-> 2010-01-01 12:00:00.0
+> -------------------
+> 2010-01-01 12:00:00
 > rows: 1
 
 select ts - 1.5 x from test;
 > X
-> ---------------------
-> 2009-12-30 12:00:00.0
+> -------------------
+> 2009-12-30 12:00:00
 > rows: 1
 
 select ts + 0.5 * t + t - t x from test;
 > X
-> ---------------------
-> 2010-01-01 00:30:00.0
+> -------------------
+> 2010-01-01 00:30:00
 > rows: 1
 
 select ts + t / 0.5 x from test;
 > X
-> ---------------------
-> 2010-01-01 02:00:00.0
+> -------------------
+> 2010-01-01 02:00:00
 > rows: 1
 
 select d + t, t + d - t x from test;
 > T + D               X
-> --------------------- ---------------------
-> 2001-01-01 01:00:00.0 2001-01-01 00:00:00.0
+> ------------------- -------------------
+> 2001-01-01 01:00:00 2001-01-01 00:00:00
 > rows: 1
 
 select 1 + d + 1, d - 1, 2 + ts + 2, ts - 2 from test;
 > DATEADD('DAY', 1, DATEADD('DAY', 1, D)) DATEADD('DAY', -1, D) DATEADD('DAY', 2, DATEADD('DAY', 2, TS)) DATEADD('DAY', -2, TS)
 > --------------------------------------- --------------------- ---------------------------------------- ----------------------
-> 2001-01-03                              2000-12-31            2010-01-05 00:00:00.0                    2009-12-30 00:00:00.0
+> 2001-01-03                              2000-12-31            2010-01-05 00:00:00                      2009-12-30 00:00:00
 > rows: 1
 
 select 1 + d + t + 1 from test;
 > DATEADD('DAY', 1, (T + DATEADD('DAY', 1, D)))
 > ---------------------------------------------
-> 2001-01-03 01:00:00.0
+> 2001-01-03 01:00:00
 > rows: 1
 
 select ts - t - 2 from test;
 > DATEADD('DAY', -2, (TS - T))
 > ----------------------------
-> 2009-12-29 23:00:00.0
+> 2009-12-29 23:00:00
 > rows: 1
 
 drop table test;
@@ -118,9 +118,9 @@ SELECT DATEADD('NANOSECOND', 1, TIME '10:00:01'), DATEADD('NS', 1, TIMESTAMP '20
 > rows: 1
 
 SELECT DATEADD('HOUR', 1, DATE '2010-01-20');
-> TIMESTAMP '2010-01-20 01:00:00.0'
-> ---------------------------------
-> 2010-01-20 01:00:00.0
+> TIMESTAMP '2010-01-20 01:00:00'
+> -------------------------------
+> 2010-01-20 01:00:00
 > rows: 1
 
 SELECT DATEADD('MINUTE', 30, TIME '12:30:55');
@@ -152,12 +152,12 @@ SELECT TIMESTAMPADD('DAY', 10, TIMESTAMP '2000-01-05 15:00:30.123456789');
 
 SELECT TIMESTAMPADD('TIMEZONE_HOUR', 1, TIMESTAMP WITH TIME ZONE '2010-01-01 10:00:00+07:30') AS T;
 > T
-> ---------------------------
-> 2010-01-01 10:00:00.0+08:30
+> -------------------------
+> 2010-01-01 10:00:00+08:30
 > rows: 1
 
 SELECT TIMESTAMPADD('TIMEZONE_MINUTE', -45, TIMESTAMP WITH TIME ZONE '2010-01-01 10:00:00+07:30') AS T;
 > T
-> ---------------------------
-> 2010-01-01 10:00:00.0+06:45
+> -------------------------
+> 2010-01-01 10:00:00+06:45
 > rows: 1

h2/src/test/org/h2/test/scripts/functions/timeanddate/parsedatetime.sql

@@ -4,14 +4,14 @@
 --
 
 CALL PARSEDATETIME('3. Februar 2001', 'd. MMMM yyyy', 'de');
-> TIMESTAMP '2001-02-03 00:00:00.0'
-> ---------------------------------
-> 2001-02-03 00:00:00.0
+> TIMESTAMP '2001-02-03 00:00:00'
+> -------------------------------
+> 2001-02-03 00:00:00
 > rows: 1
 
 CALL PARSEDATETIME('02/03/2001 04:05:06', 'MM/dd/yyyy HH:mm:ss');
-> TIMESTAMP '2001-02-03 04:05:06.0'
-> ---------------------------------
-> 2001-02-03 04:05:06.0
+> TIMESTAMP '2001-02-03 04:05:06'
+> -------------------------------
+> 2001-02-03 04:05:06
 > rows: 1
 

h2/src/test/org/h2/test/scripts/functions/timeanddate/truncate.sql

@@ -5,24 +5,24 @@
 
 select trunc('2015-05-29 15:00:00') R;
 > R
-> ---------------------
-> 2015-05-29 00:00:00.0
+> -------------------
+> 2015-05-29 00:00:00
 > rows: 1
 
 select trunc('2015-05-29') R;
 > R
-> ---------------------
-> 2015-05-29 00:00:00.0
+> -------------------
+> 2015-05-29 00:00:00
 > rows: 1
 
 select trunc(timestamp '2000-01-01 10:20:30.0') R;
 > R
-> ---------------------
-> 2000-01-01 00:00:00.0
+> -------------------
+> 2000-01-01 00:00:00
 > rows: 1
 
 select trunc(timestamp '2001-01-01 14:00:00.0') R;
 > R
-> ---------------------
-> 2001-01-01 00:00:00.0
+> -------------------
+> 2001-01-01 00:00:00
 > rows: 1

h2/src/test/org/h2/test/scripts/testScript.sql

@@ -1330,10 +1330,10 @@ INSERT INTO p VALUES('-1-01-01'), ('0-01-01'), ('0001-01-01');
 
 select d, year(d), extract(year from d), cast(d as timestamp) from p;
 > D          YEAR(D) EXTRACT(YEAR FROM D) CAST(D AS TIMESTAMP)
-> ---------- ------- -------------------- ---------------------
-> -1-01-01   -1      -1                   -1-01-01 00:00:00.0
-> 0-01-01    0       0                    0-01-01 00:00:00.0
-> 0001-01-01 1       1                    0001-01-01 00:00:00.0
+> ---------- ------- -------------------- --------------------
+> -1-01-01   -1      -1                   -1-01-01 00:00:00
+> 0-01-01    0       0                    0-01-01 00:00:00
+> 0001-01-01 1       1                    0001-01-01 00:00:00
 > rows: 3
 
 drop table p;
@@ -2490,14 +2490,14 @@ insert into test values(1, '1999-12-01 23:59:00.000');
 
 select * from test where d= '1999-12-01 23:59:00.000';
 > ID D
-> -- ---------------------
-> 1  1999-12-01 23:59:00.0
+> -- -------------------
+> 1  1999-12-01 23:59:00
 > rows: 1
 
 select * from test where d= timestamp '2006-01-01 12:00:00.000';
 > ID D
-> -- ---------------------
-> 1  2006-01-01 12:00:00.0
+> -- -------------------
+> 1  2006-01-01 12:00:00
 > rows: 1
 
 drop table test;
@@ -2684,9 +2684,9 @@ select x/10 y from system_range(1, 100) group by x/10;
 > rows: 11
 
 select timestamp '2001-02-03T10:30:33';
-> TIMESTAMP '2001-02-03 10:30:33.0'
-> ---------------------------------
-> 2001-02-03 10:30:33.0
+> TIMESTAMP '2001-02-03 10:30:33'
+> -------------------------------
+> 2001-02-03 10:30:33
 > rows: 1
 
 CREATE TABLE TEST(ID INT PRIMARY KEY, NAME VARCHAR(255));
@@ -6911,8 +6911,8 @@ INSERT INTO TEST VALUES(NULL,NULL,NULL,NULL);
 SELECT * FROM TEST;
 > ID   XT       XD         XTS
 > ---- -------- ---------- -----------------------------
-> 0    00:00:00 0001-02-03 0002-03-04 00:00:00.0
-> 1    01:02:03 0004-05-06 0007-08-09 00:01:02.0
+> 0    00:00:00 0001-02-03 0002-03-04 00:00:00
+> 1    01:02:03 0004-05-06 0007-08-09 00:01:02
 > 2    23:59:59 1999-12-31 1999-12-31 23:59:59.123456789
 > null null     null       null
 > rows: 4
@@ -6930,10 +6930,10 @@ SELECT ID, CAST(XT AS DATE) T2D, CAST(XTS AS DATE) TS2D,
 CAST(XD AS TIME) D2T, CAST(XTS AS TIME(9)) TS2T,
 CAST(XT AS TIMESTAMP) D2TS, CAST(XD AS TIMESTAMP) D2TS FROM TEST;
 > ID   T2D        TS2D       D2T      TS2T               D2TS                D2TS
-> ---- ---------- ---------- -------- ------------------ --------------------- ---------------------
-> 0    1970-01-01 0002-03-04 00:00:00 00:00:00           1970-01-01 00:00:00.0 0001-02-03 00:00:00.0
-> 1    1970-01-01 0007-08-09 00:00:00 00:01:02           1970-01-01 01:02:03.0 0004-05-06 00:00:00.0
-> 2    1970-01-01 1999-12-31 00:00:00 23:59:59.123456789 1970-01-01 23:59:59.0 1999-12-31 00:00:00.0
+> ---- ---------- ---------- -------- ------------------ ------------------- -------------------
+> 0    1970-01-01 0002-03-04 00:00:00 00:00:00           1970-01-01 00:00:00 0001-02-03 00:00:00
+> 1    1970-01-01 0007-08-09 00:00:00 00:01:02           1970-01-01 01:02:03 0004-05-06 00:00:00
+> 2    1970-01-01 1999-12-31 00:00:00 23:59:59.123456789 1970-01-01 23:59:59 1999-12-31 00:00:00
 > null null       null       null     null               null                null
 > rows: 4
 
@@ -6943,8 +6943,8 @@ SCRIPT SIMPLE NOPASSWORDS NOSETTINGS;
 > -- 4 +/- SELECT COUNT(*) FROM PUBLIC.TEST;
 > CREATE MEMORY TABLE PUBLIC.TEST( ID INT, XT TIME, XD DATE, XTS TIMESTAMP(9) );
 > CREATE USER IF NOT EXISTS SA PASSWORD '' ADMIN;
-> INSERT INTO PUBLIC.TEST(ID, XT, XD, XTS) VALUES(0, TIME '00:00:00', DATE '0001-02-03', TIMESTAMP '0002-03-04 00:00:00.0');
-> INSERT INTO PUBLIC.TEST(ID, XT, XD, XTS) VALUES(1, TIME '01:02:03', DATE '0004-05-06', TIMESTAMP '0007-08-09 00:01:02.0');
+> INSERT INTO PUBLIC.TEST(ID, XT, XD, XTS) VALUES(0, TIME '00:00:00', DATE '0001-02-03', TIMESTAMP '0002-03-04 00:00:00');
+> INSERT INTO PUBLIC.TEST(ID, XT, XD, XTS) VALUES(1, TIME '01:02:03', DATE '0004-05-06', TIMESTAMP '0007-08-09 00:01:02');
 > INSERT INTO PUBLIC.TEST(ID, XT, XD, XTS) VALUES(2, TIME '23:59:59', DATE '1999-12-31', TIMESTAMP '1999-12-31 23:59:59.123456789');
 > INSERT INTO PUBLIC.TEST(ID, XT, XD, XTS) VALUES(NULL, NULL, NULL, NULL);
 > rows: 7
@@ -6960,8 +6960,8 @@ INSERT INTO TEST VALUES(1, '2001-01-01 12:34:56.789123', '2001-01-01 12:34:56.78
 
 select * from test;
 > ID T0                  T1                    T2                     T5
-> -- --------------------- --------------------- ---------------------- -------------------------
-> 1  2001-01-01 12:34:57.0 2001-01-01 12:34:56.8 2001-01-01 12:34:56.79 2001-01-01 12:34:56.78912
+> -- ------------------- --------------------- ---------------------- -------------------------
+> 1  2001-01-01 12:34:57 2001-01-01 12:34:56.8 2001-01-01 12:34:56.79 2001-01-01 12:34:56.78912
 > rows: 1
 
 DROP TABLE IF EXISTS TEST;

h2/src/test/org/h2/test/store/TestMVTableEngine.java

@@ -1235,7 +1235,7 @@ public class TestMVTableEngine extends TestBase {
         assertEquals(3d, rs.getFloat(10));
         assertEquals("10:00:00", rs.getString(11));
         assertEquals("2001-01-01", rs.getString(12));
-        assertEquals("2010-10-10 10:10:10.0", rs.getString(13));
+        assertEquals("2010-10-10 10:10:10", rs.getString(13));
         assertEquals(1, rs.getBytes(14).length);
         assertEquals("00000000-0000-0000-0000-000000000000",
                 rs.getString(15));
@@ -1254,7 +1254,7 @@ public class TestMVTableEngine extends TestBase {
         assertEquals(32d, rs.getFloat(10));
         assertEquals("10:00:00", rs.getString(11));
         assertEquals("2001-01-01", rs.getString(12));
-        assertEquals("2010-10-10 10:10:10.0", rs.getString(13));
+        assertEquals("2010-10-10 10:10:10", rs.getString(13));
         assertEquals(1, rs.getBytes(14).length);
         assertEquals("00000000-0000-0000-0000-000000000000",
                 rs.getString(15));
@@ -1274,7 +1274,7 @@ public class TestMVTableEngine extends TestBase {
         assertEquals(0.0d, rs.getFloat(10));
         assertEquals("10:00:00", rs.getString(11));
         assertEquals("2001-01-01", rs.getString(12));
-        assertEquals("2010-10-10 10:10:10.0", rs.getString(13));
+        assertEquals("2010-10-10 10:10:10", rs.getString(13));
         assertEquals(100, rs.getBytes(14).length);
         assertEquals("00000000-0000-0000-0000-000000000000",
                 rs.getString(15));
@@ -1293,7 +1293,7 @@ public class TestMVTableEngine extends TestBase {
         assertEquals(1.0d, rs.getFloat(10));
         assertEquals("10:00:00", rs.getString(11));
         assertEquals("2001-01-01", rs.getString(12));
-        assertEquals("2010-10-10 10:10:10.0", rs.getString(13));
+        assertEquals("2010-10-10 10:10:10", rs.getString(13));
         assertEquals(100, rs.getBytes(14).length);
         assertEquals("00000000-0000-0000-0000-000000000000",
                 rs.getString(15));

h2/src/test/org/h2/test/unit/TestDate.java

@@ -97,11 +97,11 @@ public class TestDate extends TestBase {
 
         // can't convert using java.util.Date
         assertEquals(
-                Integer.MAX_VALUE + "-12-31 00:00:00.0",
+                Integer.MAX_VALUE + "-12-31 00:00:00",
                 ValueDate.parse(Integer.MAX_VALUE + "-12-31").
                 convertTo(Value.TIMESTAMP).getString());
         assertEquals(
-                Integer.MIN_VALUE + "-12-31 00:00:00.0",
+                Integer.MIN_VALUE + "-12-31 00:00:00",
                 ValueDate.parse(Integer.MIN_VALUE + "-12-31").
                 convertTo(Value.TIMESTAMP).getString());
         assertEquals(
@@ -221,7 +221,7 @@ public class TestDate extends TestBase {
     @SuppressWarnings("unlikely-arg-type")
     private void testValueTimestamp() {
         assertEquals(
-                "2001-02-03 04:05:06.0", ValueTimestamp.get(
+                "2001-02-03 04:05:06", ValueTimestamp.get(
                 Timestamp.valueOf(
                 "2001-02-03 04:05:06")).getString());
         assertEquals(
@@ -229,9 +229,9 @@ public class TestDate extends TestBase {
                 Timestamp.valueOf(
                 "2001-02-03 04:05:06.001002003")).getString());
         assertEquals(
-                "0-00-00 00:00:00.0", ValueTimestamp.fromDateValueAndNanos(0, 0).getString());
+                "0-00-00 00:00:00", ValueTimestamp.fromDateValueAndNanos(0, 0).getString());
         assertEquals(
-                "9999-12-31 23:59:59.0",
+                "9999-12-31 23:59:59",
                 ValueTimestamp.parse(
                 "9999-12-31 23:59:59").getString());
 
@@ -301,7 +301,7 @@ public class TestDate extends TestBase {
                 t1.convertScale(true, 2).getString());
         assertEquals("2001-01-01 01:01:01.1",
                 t1.convertScale(true, 1).getString());
-        assertEquals("2001-01-01 01:01:01.0",
+        assertEquals("2001-01-01 01:01:01",
                 t1.convertScale(true, 0).getString());
         t1 = ValueTimestamp.parse("-2001-01-01 01:01:01.123456789");
         assertEquals("-2001-01-01 01:01:01.123457",
@@ -310,24 +310,24 @@ public class TestDate extends TestBase {
         assertFalse(ValueTimestamp.parse("2001-01-01").
                 equals(ValueDate.parse("2001-01-01")));
 
-        assertEquals("2001-01-01 01:01:01.0",
+        assertEquals("2001-01-01 01:01:01",
                 ValueTimestamp.parse("2001-01-01").add(
                 ValueTime.parse("01:01:01")).getString());
-        assertEquals("1010-10-10 00:00:00.0",
+        assertEquals("1010-10-10 00:00:00",
                 ValueTimestamp.parse("1010-10-10 10:10:10").subtract(
                 ValueTime.parse("10:10:10")).getString());
-        assertEquals("-2001-01-01 01:01:01.0",
+        assertEquals("-2001-01-01 01:01:01",
                 ValueTimestamp.parse("-2001-01-01").add(
                 ValueTime.parse("01:01:01")).getString());
-        assertEquals("-1010-10-10 00:00:00.0",
+        assertEquals("-1010-10-10 00:00:00",
                 ValueTimestamp.parse("-1010-10-10 10:10:10").subtract(
                 ValueTime.parse("10:10:10")).getString());
 
         if (SysProperties.UNLIMITED_TIME_RANGE) {
-            assertEquals("2001-01-02 01:01:01.0",
+            assertEquals("2001-01-02 01:01:01",
                     ValueTimestamp.parse("2001-01-01").add(
                     ValueTime.parse("25:01:01")).getString());
-            assertEquals("1010-10-10 10:00:00.0",
+            assertEquals("1010-10-10 10:00:00",
                     ValueTimestamp.parse("1010-10-11 10:10:10").subtract(
                     ValueTime.parse("24:10:10")).getString());
         }

h2/src/test/org/h2/test/unit/TestTimeStampWithTimeZone.java

@@ -62,7 +62,7 @@ public class TestTimeStampWithTimeZone extends TestBase {
         stat.execute("insert into test(t1) values('2015-12-31 19:00:00.00-10:00')");
         ResultSet rs = stat.executeQuery("select t1 from test");
         rs.next();
-        assertEquals("1970-01-01 12:00:00.0+00:15", rs.getString(1));
+        assertEquals("1970-01-01 12:00:00+00:15", rs.getString(1));
         TimestampWithTimeZone ts = (TimestampWithTimeZone) rs.getObject(1);
         assertEquals(1970, ts.getYear());
         assertEquals(1, ts.getMonth());
@@ -188,7 +188,7 @@ public class TestTimeStampWithTimeZone extends TestBase {
         stat.execute("insert into test_order(t1) values('1970-01-01 12:00:01.00+01:15')");
         ResultSet rs = stat.executeQuery("select t1 from test_order order by t1");
         rs.next();
-        assertEquals("1970-01-01 12:00:01.0+01:15", rs.getString(1));
+        assertEquals("1970-01-01 12:00:01+01:15", rs.getString(1));
         conn.close();
     }
 

h2/src/test/org/h2/test/unit/TestTools.java

@@ -764,7 +764,7 @@ public class TestTools extends TestBase {
         assertEquals(new byte[] { (byte) 10, (byte) 20 }, rs.getBytes("f"));
         assertEquals("2007-12-31", rs.getString("g"));
         assertEquals("23:59:59", rs.getString("h"));
-        assertEquals("2007-12-31 23:59:59.0", rs.getString("i"));
+        assertEquals("2007-12-31 23:59:59", rs.getString("i"));
         assertFalse(rs.next());
         conn.close();
     }