activerecord-jdbc-alt-adapter 50.3.0-java

data/src/java/arjdbc/util/DateTimeUtils.java

@@ -0,0 +1,699 @@
+/*
+ * The MIT License
+ *
+ * Copyright 2014 Karol Bucek.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package arjdbc.util;
+
+import java.sql.Date;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.util.TimeZone;
+
+import org.joda.time.Chronology;
+import org.joda.time.DateTime;
+import org.joda.time.DateTimeZone;
+import org.joda.time.chrono.ISOChronology;
+import org.jruby.Ruby;
+import org.jruby.RubyFloat;
+import org.jruby.RubyString;
+import org.jruby.RubyTime;
+import org.jruby.javasupport.Java;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
+import org.jruby.util.TypeConverter;
+
+import static arjdbc.util.StringHelper.decByte;
+
+/**
+ * Utilities for handling/converting dates and times.
+ * @author kares
+ */
+public abstract class DateTimeUtils {
+    public static RubyTime toTime(final ThreadContext context, final IRubyObject value) {
+        if (!(value instanceof RubyTime)) { // unlikely
+            return (RubyTime) TypeConverter.convertToTypeWithCheck(value, context.runtime.getTime(), "to_time");
+        }
+        return (RubyTime) value;
+    }
+
+    public static DateTime dateTimeInZone(final DateTime dateTime, final DateTimeZone zone) {
+        if (zone == dateTime.getZone()) return dateTime;
+        return dateTime.withZone(zone);
+    }
+
+    @SuppressWarnings("deprecation")
+    public static ByteList timeToString(final Time time) {
+        final ByteList str = new ByteList(8); // hh:mm:ss
+
+        int hours = time.getHours();
+        int minutes = time.getMinutes();
+        int seconds = time.getSeconds();
+
+        str.append( decByte( hours / 10 ) );
+        str.append( decByte( hours % 10 ) );
+
+        str.append( ':' );
+
+        str.append( decByte( minutes / 10 ) );
+        str.append( decByte( minutes % 10 ) );
+
+        str.append( ':' );
+
+        str.append( decByte( seconds / 10 ) );
+        str.append( decByte( seconds % 10 ) );
+
+        return str;
+    }
+
+    private static final byte[] DUMMY_TIME_PREFIX = { '2','0','0','0','-','0','1','-','0','1' };
+
+    @SuppressWarnings("deprecation")
+    public static ByteList dummyTimeToString(final Timestamp time) {
+        final ByteList str = new ByteList(29); // yyyy-mm-dd hh:mm:ss.fffffffff
+
+        int hours = time.getHours();
+        int minutes = time.getMinutes();
+        int seconds = time.getSeconds();
+        int nanos = time.getNanos();
+
+        str.append( DUMMY_TIME_PREFIX );
+
+        str.append( ' ' );
+
+        formatTime(str, hours, minutes, seconds, nanos);
+
+        return str;
+    }
+
+    @SuppressWarnings("deprecation")
+    public static ByteList dateToString(final Date date) {
+        final ByteList str = new ByteList(10); // "2000-00-00"
+
+        int year = date.getYear() + 1900;
+        int month = date.getMonth() + 1;
+        int day = date.getDate();
+
+        str.append( decByte( ( year / 1000 ) % 10 ) );
+        str.append( decByte( ( year / 100 ) % 10 ) );
+        str.append( decByte( ( year / 10 ) % 10 ) );
+        str.append( decByte( year % 10 ) );
+
+        str.append( '-' );
+
+        str.append( decByte( month / 10 ) );
+        str.append( decByte( month % 10 ) );
+
+        str.append( '-' );
+
+        str.append( decByte( day / 10 ) );
+        str.append( decByte( day % 10 ) );
+
+        return str;
+    }
+
+    @SuppressWarnings("deprecation")
+    public static ByteList timestampToString(final Timestamp timestamp) {
+        final ByteList str = new ByteList(29); // yyyy-mm-dd hh:mm:ss.fffffffff
+
+        int year = timestamp.getYear() + 1900;
+        int month = timestamp.getMonth() + 1;
+        int day = timestamp.getDate();
+        int hours = timestamp.getHours();
+        int minutes = timestamp.getMinutes();
+        int seconds = timestamp.getSeconds();
+        int nanos = timestamp.getNanos();
+
+        str.append( decByte( ( year / 1000 ) % 10 ) );
+        str.append( decByte( ( year / 100 ) % 10 ) );
+        str.append( decByte( ( year / 10 ) % 10 ) );
+        str.append( decByte( year % 10 ) );
+
+        str.append( '-' );
+
+        str.append( decByte( month / 10 ) );
+        str.append( decByte( month % 10 ) );
+
+        str.append( '-' );
+
+        str.append( decByte( day / 10 ) );
+        str.append( decByte( day % 10 ) );
+
+        if ( hours != 0 || minutes != 0 || seconds != 0 || nanos != 0 ) {
+            str.append( ' ' );
+
+            formatTime(str, hours, minutes, seconds, nanos);
+        }
+
+        return str;
+    }
+
+    private static final int NANO_DIGITS_RAILS_CAN_MANAGE = 6; // 'normally' would have been 8
+
+    private static void formatTime(final ByteList str,
+        final int hours, final int minutes, final int seconds, final int nanos) {
+
+        str.append( decByte( hours / 10 ) );
+        str.append( decByte( hours % 10 ) );
+
+        str.append( ':' );
+
+        str.append( decByte( minutes / 10 ) );
+        str.append( decByte( minutes % 10 ) );
+
+        str.append( ':' );
+
+        str.append( decByte( seconds / 10 ) );
+        str.append( decByte( seconds % 10 ) );
+
+        if ( nanos != 0 ) {
+            str.append( '.' );
+            // NOTE: Rails (still) terrible at handling full nanos precision: '12:30:00.99990000'
+            int pow = 100000000; // nanos <= 999999999
+            for ( int i = 0; i < NANO_DIGITS_RAILS_CAN_MANAGE; i++ ) {
+                final int b = nanos / pow;
+                if ( b == 0 ) break; // done (no trailing zeros)
+                str.append( decByte( b % 10 ) );
+                pow = pow / 10;
+            }
+        }
+    }
+
+    @SuppressWarnings("deprecation")
+    public static RubyTime newDummyTime(final ThreadContext context, final Time time, final DateTimeZone defaultZone) {
+
+        final int hours = time.getHours();
+        final int minutes = time.getMinutes();
+        final int seconds = time.getSeconds();
+        //final int offset = time.getTimezoneOffset();
+
+        DateTime dateTime = new DateTime(2000, 1, 1, hours, minutes, seconds, defaultZone);
+        return RubyTime.newTime(context.runtime, dateTime, 0);
+    }
+
+    @SuppressWarnings("deprecation")
+    public static RubyTime newDummyTime(final ThreadContext context, final Timestamp time, final DateTimeZone defaultZone) {
+
+        final int hours = time.getHours();
+        final int minutes = time.getMinutes();
+        final int seconds = time.getSeconds();
+        final int nanos = time.getNanos(); // max 999-999-999
+
+        DateTime dateTime = new DateTime(2000, 1, 1, hours, minutes, seconds, defaultZone);
+        return RubyTime.newTime(context.runtime, dateTime, nanos);
+    }
+
+    @SuppressWarnings("deprecation")
+    public static RubyTime newTime(final ThreadContext context, final Timestamp timestamp, final DateTimeZone defaultZone) {
+
+        final int year = timestamp.getYear() + 1900;
+        final int month = timestamp.getMonth() + 1;
+        final int day = timestamp.getDate();
+        final int hours = timestamp.getHours();
+        final int minutes = timestamp.getMinutes();
+        final int seconds = timestamp.getSeconds();
+        final int nanos = timestamp.getNanos(); // max 999-999-999
+
+        DateTime dateTime = new DateTime(year, month, day, hours, minutes, seconds, 0, defaultZone);
+        return RubyTime.newTime(context.runtime, dateTime, nanos);
+    }
+
+    @SuppressWarnings("deprecation")
+    public static RubyTime newDateAsTime(final ThreadContext context, final Date date, final DateTimeZone zone) {
+
+        final int year = date.getYear() + 1900;
+        final int month = date.getMonth() + 1;
+        final int day = date.getDate();
+
+        DateTime dateTime = new DateTime(year, month, day, 0, 0, 0, 0, zone);
+        return RubyTime.newTime(context.runtime, dateTime, 0);
+    }
+
+    @SuppressWarnings("deprecation")
+    public static IRubyObject newDate(final ThreadContext context, final Date date, final DateTimeZone zone) {
+
+        final int year = date.getYear() + 1900;
+        final int month = date.getMonth() + 1;
+        final int day = date.getDate();
+
+        return newDate(context, year, month, day, ISOChronology.getInstance(zone));
+    }
+
+    // @Deprecated
+    public static Timestamp convertToTimestamp(final RubyFloat value) {
+        final Timestamp timestamp = new Timestamp(value.getLongValue() * 1000); // millis
+
+        // for usec we shall not use: ((long) floatValue * 1000000) % 1000
+        // if ( usec >= 0 ) timestamp.setNanos( timestamp.getNanos() + usec * 1000 );
+        // due doubles inaccurate precision it's better to parse to_s :
+        final ByteList strValue = ((RubyString) value.to_s()).getByteList();
+        final int dot1 = strValue.lastIndexOf('.') + 1, dot4 = dot1 + 3;
+        final int len = strValue.getRealSize() - strValue.getBegin();
+        if ( dot1 > 0 && dot4 < len ) { // skip .123 but handle .1234
+            final int end = Math.min( len - dot4, 3 );
+            CharSequence usecSeq = strValue.subSequence(dot4, end);
+            final int usec = Integer.parseInt( usecSeq.toString() );
+            if ( usec < 10 ) { // 0.1234 ~> 4
+                timestamp.setNanos( timestamp.getNanos() + usec * 100 );
+            }
+            else if ( usec < 100 ) { // 0.12345 ~> 45
+                timestamp.setNanos( timestamp.getNanos() + usec * 10 );
+            }
+            else { // if ( usec < 1000 ) { // 0.123456 ~> 456
+                timestamp.setNanos( timestamp.getNanos() + usec );
+            }
+        }
+
+        return timestamp;
+    }
+
+    public static double adjustTimeFromDefaultZone(final IRubyObject value) {
+        // Time's to_f is : ( millis * 1000 + usec ) / 1_000_000.0
+        final double time = value.convertToFloat().getDoubleValue(); // to_f
+        // NOTE: MySQL assumes default TZ thus need to adjust to match :
+        final int offset = TimeZone.getDefault().getOffset((long) time * 1000);
+        // Time's to_f is : ( millis * 1000 + usec ) / 1_000_000.0
+        return time - ( offset / 1000.0 );
+    }
+
+    public static IRubyObject parseDate(final ThreadContext context, final CharSequence str, final DateTimeZone defaultZone)
+        throws IllegalArgumentException {
+        final int len = str.length();
+
+        int year; int month; int day;
+
+        int start = nonSpaceIndex(str, 0, len); // Skip leading whitespace
+        int end = nonDigitIndex(str, start, len);
+
+        if ( end >= len ) {
+            throw new IllegalArgumentException("unexpected date value: '" + str + "'");
+        }
+
+        // year
+        year = extractIntValue(str, start, end);
+        start = end + 1; // Skip '-'
+
+        // month
+        end = nonDigitIndex(str, start, len);
+        month = extractIntValue(str, start, end);
+
+        //sep = str.charAt(end);
+        //if ( sep != '-' ) {
+        //    throw new NumberFormatException("expected date to be dash-separated, got '" + sep + "'");
+        //}
+
+        start = end + 1; // Skip '-'
+
+        // day of month
+        end = nonDigitIndex(str, start, len);
+        day = extractIntValue(str, start, end);
+
+        return newDate(context, year, month, day, ISOChronology.getInstance(defaultZone));
+    }
+
+    public static IRubyObject parseTime(final ThreadContext context, final CharSequence str, final DateTimeZone defaultZone)
+        throws IllegalArgumentException {
+        final int len = str.length();
+
+        int hour; int minute; int second;
+        int millis = 0; long nanos = 0;
+
+        int start = nonSpaceIndex(str, 0, len); // Skip leading whitespace
+        int end = nonDigitIndex(str, start, len);
+
+        if ( end >= len ) {
+            throw new IllegalArgumentException("unexpected date value: '" + str + "'");
+        }
+
+        // hours
+        hour = extractIntValue(str, start, end);
+        start = end + 1; // Skip ':'
+
+        end = nonDigitIndex(str, start, len);
+        // minutes
+        minute = extractIntValue(str, start, end);
+        start = end + 1; // Skip ':'
+
+        end = nonDigitIndex(str, start, len);
+        // seconds
+        second = extractIntValue(str, start, end);
+        start = end;
+
+        // Fractional seconds.
+        if ( start < len && str.charAt(start) == '.' ) {
+            end = nonDigitIndex(str, start + 1, len); // Skip '.'
+            int numlen = end - (start + 1);
+            if (numlen <= 3) {
+                millis = extractIntValue(str, start + 1, end);
+                for ( ; numlen < 3; ++numlen ) millis *= 10;
+            }
+            else {
+                nanos = extractIntValue(str, start + 1, end);
+                for ( ; numlen < 9; ++numlen ) nanos *= 10;
+            }
+            //start = end;
+        }
+
+        DateTime dateTime = new DateTime(2000, 1, 1, hour, minute, second, millis, defaultZone);
+        return RubyTime.newTime(context.runtime, dateTime, nanos);
+    }
+
+    public static RubyTime parseDateTime(final ThreadContext context, final CharSequence str, final DateTimeZone defaultZone)
+        throws IllegalArgumentException {
+
+        boolean hasDate = false;
+        int year = 2000; int month = 1; int day = 1;
+        boolean hasTime = false;
+        int minute = 0; int hour = 0; int second = 0;
+        int millis = 0; long nanos = 0;
+
+        DateTimeZone zone = defaultZone; boolean bcEra = false;
+
+        // We try to parse these fields in order; all are optional
+        // (but some combinations don't make sense, e.g. if you have
+        //  both date and time then they must be whitespace-separated).
+        // At least one of date and time must be present.
+
+        //   leading whitespace
+        //   yyyy-mm-dd
+        //   whitespace
+        //   hh:mm:ss
+        //   whitespace
+        //   timezone in one of the formats:  +hh, -hh, +hh:mm, -hh:mm
+        //   whitespace
+        //   if date is present, an era specifier: AD or BC
+        //   trailing whitespace
+
+        final int len = str.length();
+
+        int start = nonSpaceIndex(str, 0, len); // Skip leading whitespace
+        int end = nonDigitIndex(str, start, len);
+
+        // Possibly read date.
+        if ( end < len && str.charAt(end) == '-' ) {
+            hasDate = true;
+
+            // year
+            year = extractIntValue(str, start, end);
+            start = end + 1; // Skip '-'
+
+            // month
+            end = nonDigitIndex(str, start, len);
+            month = extractIntValue(str, start, end);
+
+            char sep = str.charAt(end);
+            if ( sep != '-' ) {
+                throw new IllegalArgumentException("expected date to be dash-separated, got '" + sep + "'");
+            }
+
+            start = end + 1; // Skip '-'
+
+            // day of month
+            end = nonDigitIndex(str, start, len);
+            day = extractIntValue(str, start, end);
+
+            start = nonSpaceIndex(str, end, len); // Skip trailing whitespace
+        }
+
+        // Possibly read time.
+        if ( start < len && Character.isDigit( str.charAt(start) ) ) {
+            hasTime = true;
+
+            // hours
+            end = nonDigitIndex(str, start, len);
+            hour = extractIntValue(str, start, end);
+
+            //sep = str.charAt(end);
+            //if ( sep != ':' ) {
+            //    throw new IllegalArgumentException("expected time to be colon-separated, got '" + sep + "'");
+            //}
+
+            start = end + 1; // Skip ':'
+
+            // minutes
+            end = nonDigitIndex(str, start, len);
+            minute = extractIntValue(str, start, end);
+
+            //sep = str.charAt(end);
+            //if ( sep != ':' ) {
+            //    throw new IllegalArgumentException("expected time to be colon-separated, got '" + sep + "'");
+            //}
+
+            start = end + 1; // Skip ':'
+
+            // seconds
+            end = nonDigitIndex(str, start, len);
+            second = extractIntValue(str, start, end);
+            start = end;
+
+            // Fractional seconds.
+            if ( start < len && str.charAt(start) == '.' ) {
+                end = nonDigitIndex(str, start + 1, len); // Skip '.'
+                int numlen = end - (start + 1);
+                if (numlen <= 3) {
+                    millis = extractIntValue(str, start + 1, end);
+                    for ( ; numlen < 3; ++numlen ) millis *= 10;
+                }
+                else {
+                    // Make sure we always define millis to work around bug in
+                    // strftime('%6N') in older version of JRuby (discovered in 9.1.16.0)
+                    millis = extractIntValue(str, start + 1, start + 4);
+                    nanos = extractIntValue(str, start + 4, end);
+                    for ( ; numlen < 9; ++numlen ) nanos *= 10;
+                }
+
+                start = end;
+            }
+
+            start = nonSpaceIndex(str, start, len); // Skip trailing whitespace
+        }
+
+        // Possibly read timezone.
+        char sep = start < len ? str.charAt(start) : '\0';
+        if ( sep == '+' || sep == '-' ) {
+            int zoneSign = (sep == '-') ? -1 : 1;
+            int hoursOffset, minutesOffset, secondsOffset;
+
+            end = nonDigitIndex(str, start + 1, len);    // Skip +/-
+            hoursOffset = extractIntValue(str, start + 1, end);
+            start = end;
+
+            if ( start < len && str.charAt(start) == ':' ) {
+                end = nonDigitIndex(str, start + 1, len);  // Skip ':'
+                minutesOffset = extractIntValue(str, start + 1, end);
+                start = end;
+            } else {
+                minutesOffset = 0;
+            }
+
+            secondsOffset = 0;
+            if ( start < len && str.charAt(start) == ':' ) {
+                end = nonDigitIndex(str, start + 1, len);  // Skip ':'
+                secondsOffset = extractIntValue(str, start + 1, end);
+                start = end;
+            }
+
+            // Setting offset does not seem to work correctly in all
+            // cases.. So get a fresh calendar for a synthetic timezone
+            // instead
+
+            int offset = zoneSign * hoursOffset * 60;
+            if (offset < 0) {
+                offset = offset - Math.abs(minutesOffset);
+            } else {
+                offset = offset + minutesOffset;
+            }
+            offset = (offset * 60 + secondsOffset) * 1000;
+            zone = DateTimeZone.forOffsetMillis(offset);
+
+            start = nonSpaceIndex(str, start, len); // Skip trailing whitespace
+        }
+
+        if ( hasDate && start < len ) {
+            final char e1 = str.charAt(start);
+            if ( e1 == 'A' && str.charAt(start + 1) == 'D' ) {
+                bcEra = false; start += 2;
+            }
+            else if ( e1 == 'B' && str.charAt(start + 1) == 'C' ) {
+                bcEra = true; start += 2;
+            }
+        }
+
+        if ( start < len ) {
+            throw new IllegalArgumentException("trailing junk: '" + str.subSequence(start, len - start) + "' on '" + str + "'");
+        }
+        if ( ! hasTime && ! hasDate ) {
+            throw new IllegalArgumentException("'"+ str +"' has neither date nor time");
+        }
+
+        if ( bcEra ) year = -1 * year + 1; // since JODA is treating year 0 as non-existent
+
+        DateTime dateTime = new DateTime(year, month, day, hour, minute, second, millis, zone);
+        return RubyTime.newTime(context.runtime, dateTime, nanos);
+    }
+
+    private static IRubyObject newDate(final ThreadContext context, final int year, final int month, final int day,
+                                       final ISOChronology chronology) {
+        // NOTE: JRuby really needs a native date.rb until than its a bit costly going from ...
+        // java.sql.Date -> allocating a DateTime proxy, help a bit by shooting at the internals
+        //
+        //  def initialize(dt_or_ajd=0, of=0, sg=ITALY, sub_millis=0)
+        //    if JODA::DateTime === dt_or_ajd
+        //      @dt = dt_or_ajd
+
+        DateTime dateTime = new DateTime(year, month, day, 0, 0, 0, 0, chronology);
+
+        final Ruby runtime = context.runtime;
+        return runtime.getClass("Date").newInstance(context, Java.getInstance(runtime, dateTime), Block.NULL_BLOCK);
+    }
+
+    @SuppressWarnings("deprecation")
+    private static int nonSpaceIndex(final CharSequence str, int beg, int len) {
+        for ( int i = beg; i < len; i++ ) {
+            if ( ! Character.isSpace( str.charAt(i) ) ) return i;
+        }
+        return len;
+    }
+
+    private static int nonDigitIndex(final CharSequence str, int beg, int len) {
+        for ( int i = beg; i < len; i++ ) {
+            if ( ! Character.isDigit( str.charAt(i) ) ) return i;
+        }
+        return len;
+    }
+
+    private static int extractIntValue(final CharSequence str, int beg, int end) {
+        int n = 0;
+        for ( int i = beg; i < end; i++ ) {
+            n = 10 * n + ( str.charAt(i) - '0' );
+        }
+        return n;
+    }
+
+
+    private static final char[] ZEROS = {'0', '0', '0', '0', '0', '0'};
+    private static final char[][] NUMBERS;
+
+    static {
+        // maximum value is 60 (seconds)
+        NUMBERS = new char[60][];
+        for (int i = 0; i < NUMBERS.length; i++) {
+            NUMBERS[i] = ((i < 10 ? "0" : "") + Integer.toString(i)).toCharArray();
+        }
+    }
+
+    /**
+     * Converts a ruby timestamp to a java string, optionally with timezone and timezone adjustment
+     * @param context
+     * @param value the ruby value, typically a Time
+     * @param zone DateTimeZone to adjust to, optional
+     * @param withZone include timezone in the string?
+     * @return timestamp as string
+     */
+    public static String timestampTimeToString(final ThreadContext context,
+                                               final IRubyObject value, DateTimeZone zone, boolean withZone) {
+        RubyTime timeValue = toTime(context, value);
+        DateTime dt = timeValue.getDateTime();
+
+        StringBuilder sb = new StringBuilder(36);
+
+        int year = dt.getYear();
+        if (year <= 0) {
+            year--;
+        } else if (zone != null) {
+            dt = dateTimeInZone(dt, zone);
+            year = dt.getYear();
+        }
+
+        Chronology chrono = dt.getChronology();
+        long millis = dt.getMillis();
+
+        // always use 4 digits for year to avoid short dates being misinterpreted
+        sb.append(Math.abs(year));
+        int lead = 4 - sb.length();
+        if (lead > 0) sb.insert(0, ZEROS, 0, lead);
+        sb.append('-');
+        sb.append(NUMBERS[chrono.monthOfYear().get(millis)]);
+        sb.append('-');
+        sb.append(NUMBERS[chrono.dayOfMonth().get(millis)]);
+        if (year < 0) sb.append(" BC");
+        sb.append(' ');
+
+        appendTime(sb, chrono, millis, (int) timeValue.getUSec(), withZone);
+
+        return sb.toString();
+    }
+
+    /**
+     * Converts a ruby time to a java string, optionally with timezone and timezone adjustment
+     * @param context
+     * @param value the ruby value, typically a Time
+     * @param zone DateTimeZone to adjust to, optional
+     * @param withZone include timezone in the string?
+     * @return time as string
+     */
+    public static String timeString(final ThreadContext context,
+                                    final IRubyObject value, DateTimeZone zone, boolean withZone) {
+        StringBuilder sb = new StringBuilder(21);
+        RubyTime timeValue = toTime(context, value);
+        DateTime dt = timeValue.getDateTime();
+        if (zone != null) dt = dateTimeInZone(dt, zone);
+
+        appendTime(sb, dt.getChronology(), dt.getMillis(), (int) timeValue.getUSec(), withZone);
+        return sb.toString();
+    }
+
+    private static void appendTime(StringBuilder sb, Chronology chrono,
+                                   long millis, int usec, boolean withZone) {
+        sb.append(NUMBERS[chrono.hourOfDay().get(millis)]);
+        sb.append(':');
+        sb.append(NUMBERS[chrono.minuteOfHour().get(millis)]);
+        sb.append(':');
+        sb.append(NUMBERS[chrono.secondOfMinute().get(millis)]);
+
+        // PG has microsecond resolution. Change when nanos are required
+        int micros = chrono.millisOfSecond().get(millis) * 1000 + usec;
+        if (micros > 0) {
+            sb.append('.');
+
+            int len = sb.length();
+            sb.append(micros);
+            int lead = 6 - (sb.length() - len);
+            if (lead > 0) sb.insert(len, ZEROS, 0, lead);
+
+            for (int end = sb.length() - 1; sb.charAt(end) == '0'; end--) {
+                sb.setLength(end);
+            }
+        }
+
+        if (withZone) {
+            int offset = chrono.getZone().getOffset(millis) / 1000;
+            int absoff = Math.abs(offset);
+            int hours = absoff / 3600;
+            int mins = (absoff - hours * 3600) / 60;
+
+            sb.append(offset < 0 ? '-' : '+');
+            sb.append(NUMBERS[hours]).append(':').append(NUMBERS[mins]);
+        }
+    }
+}