embulk-filter-timestamp_format 0.1.5 → 0.1.6

data/src/main/java/org/embulk/filter/timestamp_format/TimestampParser.java

@@ -17,13 +17,14 @@ import org.embulk.spi.time.TimestampParseException;
 import org.joda.time.DateTimeZone;
 import org.jruby.embed.ScriptingContainer;
 
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.TimeZone;
 
-public class TimestampParser
-{
-    public interface Task
-    {
+public class TimestampParser {
+    public interface Task {
         @Config("default_from_timezone")
         @ConfigDefault("\"UTC\"")
         DateTimeZone getDefaultFromTimeZone();
@@ -33,8 +34,7 @@ public class TimestampParser
         List<String> getDefaultFromTimestampFormat();
     }
 
-    public interface TimestampColumnOption
-    {
+    public interface TimestampColumnOption {
         @Config("from_timezone")
         @ConfigDefault("null")
         Optional<DateTimeZone> getFromTimeZone();
@@ -44,60 +44,71 @@ public class TimestampParser
         Optional<List<String>> getFromFormat();
     }
 
-    private final List<JRubyTimeParserHelper> helperList;
+    private final List<JRubyTimeParserHelper> jrubyParserList = new ArrayList<JRubyTimeParserHelper>();
+    private final List<SimpleDateFormat> javaParserList = new ArrayList<SimpleDateFormat>();
     private final DateTimeZone defaultFromTimeZone;
 
-    TimestampParser(PluginTask task)
-    {
+    TimestampParser(PluginTask task) {
         this(task.getJRuby(), task.getDefaultFromTimestampFormat(), task.getDefaultFromTimeZone());
     }
 
-    public TimestampParser(PluginTask task, TimestampColumnOption columnOption)
-    {
+    public TimestampParser(PluginTask task, TimestampColumnOption columnOption) {
         this(task.getJRuby(),
                 columnOption.getFromFormat().or(task.getDefaultFromTimestampFormat()),
                 columnOption.getFromTimeZone().or(task.getDefaultFromTimeZone()));
     }
 
-    public TimestampParser(ScriptingContainer jruby, List<String> formatList, DateTimeZone defaultFromTimeZone)
-    {
+    public TimestampParser(ScriptingContainer jruby, List<String> formatList, DateTimeZone defaultFromTimeZone) {
         JRubyTimeParserHelperFactory helperFactory = (JRubyTimeParserHelperFactory) jruby.runScriptlet("Embulk::Java::TimeParserHelper::Factory.new");
         // TODO get default current time from ExecTask.getExecTimestamp
-        this.helperList = new ArrayList<JRubyTimeParserHelper>();
         for (String format : formatList) {
-            JRubyTimeParserHelper helper = (JRubyTimeParserHelper) helperFactory.newInstance(format, 1970, 1, 1, 0, 0, 0, 0);  // TODO default time zone
-            this.helperList.add(helper);
+            if (format.contains("%")) {
+                JRubyTimeParserHelper helper = (JRubyTimeParserHelper) helperFactory.newInstance(format, 1970, 1, 1, 0, 0, 0, 0);  // TODO default time zone
+                this.jrubyParserList.add(helper);
+            } else {
+                SimpleDateFormat parser = new SimpleDateFormat(format);
+                parser.setTimeZone(defaultFromTimeZone.toTimeZone());
+                this.javaParserList.add(parser);
+            }
         }
         this.defaultFromTimeZone = defaultFromTimeZone;
     }
 
-    public DateTimeZone getDefaultFromTimeZone()
-    {
+    public DateTimeZone getDefaultFromTimeZone() {
         return defaultFromTimeZone;
     }
 
-    public Timestamp parse(String text) throws TimestampParseException
-    {
-        JRubyTimeParserHelper helper = null;
+    public Timestamp parse(String text) throws TimestampParseException, ParseException {
+        if (!jrubyParserList.isEmpty()) {
+            return jrubyParse(text);
+        } else if (!javaParserList.isEmpty()) {
+            return javaParse(text);
+        } else {
+            assert false;
+            throw new RuntimeException();
+        }
+    }
+
+    private Timestamp jrubyParse(String text) throws TimestampParseException {
         long localUsec = -1;
         TimestampParseException exception = null;
 
-        for (JRubyTimeParserHelper h : helperList) {
+        JRubyTimeParserHelper helper = null;
+        for (JRubyTimeParserHelper h : jrubyParserList) {
             helper = h;
             try {
-                localUsec = helper.strptimeUsec(text);
+                localUsec = helper.strptimeUsec(text); // NOTE: micro second resolution
                 break;
-            }
-            catch (TimestampParseException ex) {
+            } catch (TimestampParseException ex) {
                 exception = ex;
             }
         }
         if (localUsec == -1) {
             throw exception;
         }
+        DateTimeZone timeZone = defaultFromTimeZone;
         String zone = helper.getZone();
 
-        DateTimeZone timeZone = defaultFromTimeZone;
         if (zone != null) {
             // TODO cache parsed zone?
             timeZone = parseDateTimeZone(zone);
@@ -112,4 +123,24 @@ public class TimestampParser
 
         return Timestamp.ofEpochSecond(sec, usec * 1000);
     }
+
+    private Timestamp javaParse(String text) throws ParseException {
+        long msec = -1;
+        ParseException exception = null;
+
+        for (SimpleDateFormat parser : javaParserList) {
+            try {
+                msec = parser.parse(text).getTime(); // NOTE: milli second resolution
+                break;
+            } catch (ParseException ex) {
+                exception = ex;
+            }
+        }
+        if (msec == -1) {
+            throw exception;
+        }
+
+        long nanoAdjustment = msec * 1000000;
+        return Timestamp.ofEpochSecond(0, nanoAdjustment);
+    }
 }

data/src/main/java/org/embulk/filter/timestamp_format/TimestampUnit.java

@@ -0,0 +1,112 @@
+package org.embulk.filter.timestamp_format;
+
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import org.embulk.spi.time.Timestamp;
+
+@JsonDeserialize(using=TimestampUnitDeserializer.class)
+public enum TimestampUnit {
+    Second {
+        @Override
+        public int scale() {
+            return 1;
+        }
+
+        @Override
+        public int scaleToNano() {
+            return 1000000000;
+        }
+    },
+    MilliSecond {
+        @Override
+        public int scale() {
+            return 1000;
+        }
+
+        @Override
+        public int scaleToNano() {
+            return 1000000;
+        }
+    },
+    MicroSecond {
+        @Override
+        public int scale() {
+            return 1000000;
+        }
+
+        @Override
+        public int scaleToNano() {
+            return 1000;
+        }
+    },
+    NanoSecond {
+        @Override
+        public int scale() {
+            return 1000000000;
+        }
+
+        @Override
+        public int scaleToNano() {
+            return 1;
+        }
+    };
+
+    public abstract int scale();
+    public abstract int scaleToNano();
+
+    public static Timestamp toTimestamp(long value, TimestampUnit fromUnit)
+    {
+        long nanoAdjustment = value * fromUnit.scaleToNano();
+        return Timestamp.ofEpochSecond(0, nanoAdjustment);
+    }
+
+    public static Timestamp toTimestamp(double value, TimestampUnit fromUnit)
+    {
+        long nanoAdjustment = (long) (value * fromUnit.scaleToNano());
+        return Timestamp.ofEpochSecond(0, nanoAdjustment);
+    }
+
+    public static long toLong(Timestamp value, TimestampUnit toUnit)
+    {
+        long epochSecond = value.getEpochSecond() * toUnit.scale();
+        long nanoIntegerPart = value.getNano() / toUnit.scaleToNano();
+        return epochSecond + nanoIntegerPart;
+
+    }
+    public static double toDouble(Timestamp value, TimestampUnit toUnit)
+    {
+        long epochSecond = value.getEpochSecond() * toUnit.scale();
+        long nanoIntegerPart = value.getNano() / toUnit.scaleToNano();
+        long nanoDecimalPart = value.getNano() - (nanoIntegerPart * toUnit.scaleToNano());
+        return epochSecond + nanoIntegerPart + (nanoDecimalPart / (double) toUnit.scaleToNano());
+    }
+
+    public static long changeUnit(long value, TimestampUnit fromUnit, TimestampUnit toUnit)
+    {
+        if (fromUnit.scale() == toUnit.scale()) {
+            return value;
+        }
+        else if (fromUnit.scale() < toUnit.scale()) {
+            long factor = toUnit.scale() / fromUnit.scale();
+            return value * factor;
+        }
+        else {
+            long divideFactor = fromUnit.scale() / toUnit.scale();
+            return value / divideFactor;
+        }
+    }
+
+    public static double changeUnit(double value, TimestampUnit fromUnit, TimestampUnit toUnit)
+    {
+        if (fromUnit.scale() == toUnit.scale()) {
+            return value;
+        }
+        else if (fromUnit.scale() < toUnit.scale()) {
+            long factor = toUnit.scale() / fromUnit.scale();
+            return value * factor;
+        }
+        else {
+            long divideFactor = fromUnit.scale() / toUnit.scale();
+            return value / (double)divideFactor;
+        }
+    }
+}

data/src/main/java/org/embulk/filter/timestamp_format/TimestampUnitDeserializer.java

@@ -0,0 +1,54 @@
+package org.embulk.filter.timestamp_format;
+
+import java.util.Map;
+import java.io.IOException;
+import com.google.common.base.Joiner;
+import com.google.common.collect.ImmutableMap;
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.deser.std.FromStringDeserializer;
+import com.fasterxml.jackson.databind.JsonMappingException;
+
+public class TimestampUnitDeserializer
+        extends FromStringDeserializer<TimestampUnit>
+{
+    private static final Map<String, TimestampUnit> stringToTimestampUnitMap;
+
+    static {
+        ImmutableMap.Builder<String, TimestampUnit> builder = ImmutableMap.builder();
+        builder.put("Second", TimestampUnit.Second);
+        builder.put("second", TimestampUnit.Second);
+        builder.put("sec", TimestampUnit.Second);
+        builder.put("MilliSecond", TimestampUnit.MilliSecond);
+        builder.put("millisecond", TimestampUnit.MilliSecond);
+        builder.put("milli_second", TimestampUnit.MilliSecond);
+        builder.put("ms", TimestampUnit.MilliSecond);
+        builder.put("MicroSecond", TimestampUnit.MicroSecond);
+        builder.put("microsecond", TimestampUnit.MicroSecond);
+        builder.put("micro_second", TimestampUnit.MicroSecond);
+        builder.put("us", TimestampUnit.MicroSecond);
+        builder.put("NanoSecond", TimestampUnit.NanoSecond);
+        builder.put("nanosecond", TimestampUnit.NanoSecond);
+        builder.put("nano_second", TimestampUnit.NanoSecond);
+        builder.put("ns", TimestampUnit.NanoSecond);
+        stringToTimestampUnitMap = builder.build();
+    }
+
+    public TimestampUnitDeserializer()
+    {
+        super(TimestampUnit.class);
+    }
+
+    @Override
+    protected TimestampUnit _deserialize(String value, DeserializationContext context)
+            throws IOException
+    {
+        TimestampUnit t = stringToTimestampUnitMap.get(value);
+        if (t == null) {
+            throw new JsonMappingException(
+                    String.format("Unknown type name '%s'. Supported types are: %s",
+                            value,
+                            Joiner.on(", ").join(stringToTimestampUnitMap.keySet())));
+        }
+        return t;
+    }
+}

data/src/main/java/org/embulk/filter/timestamp_format/cast/DoubleCast.java

@@ -0,0 +1,32 @@
+package org.embulk.filter.timestamp_format.cast;
+
+import org.embulk.filter.timestamp_format.TimestampFormatter;
+import org.embulk.filter.timestamp_format.TimestampUnit;
+import org.embulk.spi.DataException;
+import org.embulk.spi.time.Timestamp;
+
+public class DoubleCast
+{
+    private DoubleCast() {}
+
+    public static String asString(double value, TimestampUnit fromUnit, TimestampFormatter formatter) throws DataException
+    {
+        Timestamp timestamp = TimestampUnit.toTimestamp(value, fromUnit);
+        return formatter.format(timestamp);
+    }
+
+    public static Timestamp asTimestamp(double value, TimestampUnit fromUnit) throws DataException
+    {
+        return TimestampUnit.toTimestamp(value, fromUnit);
+    }
+
+    public static long asLong(double value, TimestampUnit fromUnit, TimestampUnit toUnit) throws DataException
+    {
+        return (long) TimestampUnit.changeUnit(value, fromUnit, toUnit);
+    }
+
+    public static double asDouble(double value, TimestampUnit fromUnit, TimestampUnit toUnit) throws DataException
+    {
+        return TimestampUnit.changeUnit(value, fromUnit, toUnit);
+    }
+}

data/src/main/java/org/embulk/filter/timestamp_format/cast/LongCast.java

@@ -0,0 +1,32 @@
+package org.embulk.filter.timestamp_format.cast;
+
+import org.embulk.filter.timestamp_format.TimestampFormatter;
+import org.embulk.filter.timestamp_format.TimestampUnit;
+import org.embulk.spi.DataException;
+import org.embulk.spi.time.Timestamp;
+
+public class LongCast
+{
+    private LongCast() {}
+
+    public static String asString(long value, TimestampUnit fromUnit, TimestampFormatter formatter) throws DataException
+    {
+        Timestamp timestamp = TimestampUnit.toTimestamp(value, fromUnit);
+        return formatter.format(timestamp);
+    }
+
+    public static Timestamp asTimestamp(long value, TimestampUnit fromUnit) throws DataException
+    {
+        return TimestampUnit.toTimestamp(value, fromUnit);
+    }
+
+    public static long asLong(long value, TimestampUnit fromUnit, TimestampUnit toUnit) throws DataException
+    {
+        return TimestampUnit.changeUnit(value, fromUnit, toUnit);
+    }
+
+    public static double asDouble(long value, TimestampUnit fromUnit, TimestampUnit toUnit) throws DataException
+    {
+        return (double) TimestampUnit.changeUnit(value, fromUnit, toUnit);
+    }
+}

data/src/main/java/org/embulk/filter/timestamp_format/cast/StringCast.java

@@ -2,10 +2,13 @@ package org.embulk.filter.timestamp_format.cast;
 
 import org.embulk.filter.timestamp_format.TimestampFormatter;
 import org.embulk.filter.timestamp_format.TimestampParser;
+import org.embulk.filter.timestamp_format.TimestampUnit;
 import org.embulk.spi.DataException;
 import org.embulk.spi.time.Timestamp;
 import org.embulk.spi.time.TimestampParseException;
 
+import java.text.ParseException;
+
 public class StringCast
 {
     private StringCast() {}
@@ -24,6 +27,9 @@ public class StringCast
         catch (TimestampParseException ex) {
             throw new DataException(buildErrorMessage(value), ex);
         }
+        catch (ParseException ex) {
+            throw new DataException(buildErrorMessage(value), ex);
+        }
     }
 
     public static Timestamp asTimestamp(String value, TimestampParser parser) throws DataException
@@ -34,26 +40,36 @@ public class StringCast
         catch (TimestampParseException ex) {
             throw new DataException(buildErrorMessage(value), ex);
         }
+        catch (ParseException ex) {
+            throw new DataException(buildErrorMessage(value), ex);
+        }
     }
 
-    public static long asLong(String value, TimestampParser parser) throws DataException
+    public static long asLong(String value, TimestampParser parser, TimestampUnit toUnit) throws DataException
     {
         try {
             Timestamp timestamp = parser.parse(value);
-            return timestamp.getEpochSecond();
+            return TimestampUnit.toLong(timestamp, toUnit);
         }
         catch (TimestampParseException ex) {
             throw new DataException(buildErrorMessage(value), ex);
         }
+        catch (ParseException ex) {
+            throw new DataException(buildErrorMessage(value), ex);
+        }
     }
-    public static double asDouble(String value, TimestampParser parser) throws DataException
+
+    public static double asDouble(String value, TimestampParser parser, TimestampUnit toUnit) throws DataException
     {
         try {
             Timestamp timestamp = parser.parse(value);
-            return TimestampCast.asDouble(timestamp);
+            return TimestampUnit.toDouble(timestamp, toUnit);
         }
         catch (TimestampParseException ex) {
             throw new DataException(buildErrorMessage(value), ex);
         }
+        catch (ParseException ex) {
+            throw new DataException(buildErrorMessage(value), ex);
+        }
     }
 }

data/src/main/java/org/embulk/filter/timestamp_format/cast/TimestampCast.java

@@ -1,6 +1,7 @@
 package org.embulk.filter.timestamp_format.cast;
 
 import org.embulk.filter.timestamp_format.TimestampFormatter;
+import org.embulk.filter.timestamp_format.TimestampUnit;
 import org.embulk.spi.DataException;
 import org.embulk.spi.time.Timestamp;
 
@@ -18,15 +19,13 @@ public class TimestampCast
         return value;
     }
 
-    public static long asLong(Timestamp value) throws DataException
+    public static long asLong(Timestamp value, TimestampUnit toUnit) throws DataException
     {
-        return value.getEpochSecond();
+        return TimestampUnit.toLong(value, toUnit);
     }
 
-    public static double asDouble(Timestamp value) throws DataException
+    public static double asDouble(Timestamp value, TimestampUnit toUnit) throws DataException
     {
-        long epoch = value.getEpochSecond();
-        int nano = value.getNano();
-        return (double) epoch + ((double) nano / 1000000000.0);
+        return TimestampUnit.toDouble(value, toUnit);
     }
 }