embulk-input-mongodb 0.3.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9e8662a212da54dab9c41190514709db11ee5db3
-  data.tar.gz: e914845e6bdbf89e1bdf4f8c23f968f316cbd130
+  metadata.gz: fc232a73722d1157d53b5d4de1374cadd11cd234
+  data.tar.gz: 7792d6114a467b793fcacfaa9a64df7bfe1e5aa3
 SHA512:
-  metadata.gz: 6031e390a789b9feefb3918eefdd051ac23ad7e95594d56d65dfbf6af034b9611437979cbc30f9bfb9fe9fe49d16323171a455b4ac4d7903c4b361353099182f
-  data.tar.gz: 2a2bd692dd0506b46036ebb10e50af514d1a251f72fc74d853995e7a1d28cb3ca68036fb26faab045862cc85ed25ec75344b761f60251b9220fb10aa5f37ad53
+  metadata.gz: 1af752c57c9fc04d2d65e9665d6c11c739be8c2805c07b6bd65fad7a244685bf78eaf8da6a5a84e59d48e1fd18db671690789ace2d9cd7c6d62d2e1afcb5c390
+  data.tar.gz: 2cb4e589f0e8d524414b6a51135b4931ca91514f811b036c5d1452e2933045a4a86d7c3a615ce31eef85d8c23e66c1ba78d8ad952d9a5dd324e9c15682933038

data/README.md

@@ -28,6 +28,8 @@ This plugin only works with embulk >= 0.8.8.
 - **query**: a JSON document used for [querying](https://docs.mongodb.com/manual/tutorial/query-documents/) on the source collection. Documents are loaded from the colleciton if they match with this condition. (string, optional)
 - **projection**: A JSON document used for [projection](https://docs.mongodb.com/manual/reference/operator/projection/positional/) on query results. Fields in a document are used only if they match with this condition. (string, optional)
 - **sort**: ordering of results (string, optional)
+- **incremental_field** list of field name (list, optional, can't use with sort option)
+- **last_record** (hash, optional) last loaded record for incremental load
 - **stop_on_invalid_record** Stop bulk load transaction if a document includes invalid record (such as unsupported object type) (boolean, optional, default: false)
 - **json_column_name**: column name used in outputs (string, optional, default: "json")
 
@@ -54,6 +56,52 @@ in:
   sort: '{ "field1": 1 }'
 ```
 
+### Incremental loading
+
+```yaml
+in:
+  type: mongodb
+  uri: mongodb://myuser:mypassword@localhost:27017/my_database
+  collection: "my_collection"
+  query: '{ field1: { $gt: 3 } }'
+  projection: '{ "_id": 1, "field1": 1, "field2": 1 }'
+  incremental_field:
+    - "field2"
+  last_record: {"field2": 13215}
+```
+
+Plugin will create new query and sort value.
+You can't use `incremental_field` option with `sort` option at the same time.
+
+```
+query { field1: { $gt: 3 }, field2: { $gt: 13215}}
+sort {"field2", 1} # field2 ascending
+```
+
+You have to specify last_record with special characters when field type is `ObjectId` or `DateTime`.
+
+```yaml
+# ObjectId field
+in:
+  type: mongodb
+  incremental_field:
+    - "_id"
+  last_record: {"_id": {"$oid": "5739b2261c21e58edfe39716"}}
+
+# DateTime field
+in:
+  type: mongodb
+  incremental_field:
+    - "time_field"
+  last_record: {"time_field": {"$date": "2015-01-25T13:23:15.000Z"}}
+```
+
+#### Run Incremental load
+
+```
+$ embulk run /path/to/config.yml -c config-diff.yml
+```
+
 ### Advanced usage with filter plugins
 
 ```yaml

data/build.gradle

@@ -17,7 +17,7 @@ configurations {
     provided
 }
 
-version = "0.3.2"
+version = "0.4.0"
 
 sourceCompatibility = 1.7
 targetCompatibility = 1.7

data/src/main/java/org/embulk/input/mongodb/MongodbInputPlugin.java

@@ -1,5 +1,6 @@
 package org.embulk.input.mongodb;
 
+import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.common.base.Optional;
 import com.google.common.base.Throwables;
 import com.mongodb.MongoClient;
@@ -19,6 +20,9 @@ import org.embulk.config.ConfigDiff;
 import org.embulk.config.ConfigException;
 import org.embulk.config.ConfigInject;
 import org.embulk.config.ConfigSource;
+import org.embulk.config.DataSource;
+import org.embulk.config.DataSourceImpl;
+import org.embulk.config.ModelManager;
 import org.embulk.config.Task;
 import org.embulk.config.TaskReport;
 import org.embulk.config.TaskSource;
@@ -36,8 +40,12 @@ import org.slf4j.Logger;
 
 import javax.validation.constraints.Min;
 
+import java.io.IOException;
 import java.net.UnknownHostException;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map;
 
 public class MongodbInputPlugin
         implements InputPlugin
@@ -63,10 +71,12 @@ public class MongodbInputPlugin
         @Config("query")
         @ConfigDefault("\"{}\"")
         String getQuery();
+        void setQuery(String query);
 
         @Config("sort")
         @ConfigDefault("\"{}\"")
         String getSort();
+        void setSort(String sort);
 
         @Config("id_field_name")
         @ConfigDefault("\"_id\"")
@@ -85,6 +95,14 @@ public class MongodbInputPlugin
         @ConfigDefault("\"record\"")
         String getJsonColumnName();
 
+        @Config("incremental_field")
+        @ConfigDefault("null")
+        Optional<List<String>> getIncrementalField();
+
+        @Config("last_record")
+        @ConfigDefault("null")
+        Optional<Map<String, Object>> getLastRecord();
+
         @ConfigInject
         BufferAllocator getBufferAllocator();
     }
@@ -99,6 +117,13 @@ public class MongodbInputPlugin
         if (task.getFields().isPresent()) {
             throw new ConfigException("field option was deprecated so setting will be ignored");
         }
+        if (task.getIncrementalField().isPresent() && !task.getSort().equals("{}")) {
+            throw new ConfigException("both of sort and incremental_load can't be used together");
+        }
+
+        Map<String, String> newCondition = buildIncrementalCondition(task);
+        task.setQuery(newCondition.get("query"));
+        task.setSort(newCondition.get("sort"));
 
         validateJsonField("projection", task.getProjection());
         validateJsonField("query", task.getQuery());
@@ -120,8 +145,14 @@ public class MongodbInputPlugin
             Schema schema, int taskCount,
             InputPlugin.Control control)
     {
-        control.run(taskSource, schema, taskCount);
-        return Exec.newConfigDiff();
+        List<TaskReport> report = control.run(taskSource, schema, taskCount);
+
+        ConfigDiff configDiff = Exec.newConfigDiff();
+        if (report.size() > 0 && report.get(0).has("last_record")) {
+            configDiff.set("last_record", report.get(0).get(Map.class, "last_record"));
+        }
+
+        return configDiff;
     }
 
     @Override
@@ -142,13 +173,14 @@ public class MongodbInputPlugin
         PageBuilder pageBuilder = new PageBuilder(allocator, schema, output);
         final Column column = pageBuilder.getSchema().getColumns().get(0);
 
+        ValueCodec valueCodec = new ValueCodec(task.getStopOnInvalidRecord(), task);
         MongoCollection<Value> collection;
         try {
             MongoDatabase db = connect(task);
 
             CodecRegistry registry = CodecRegistries.fromRegistries(
                     MongoClient.getDefaultCodecRegistry(),
-                    CodecRegistries.fromCodecs(new ValueCodec(task.getStopOnInvalidRecord(), task))
+                    CodecRegistries.fromCodecs(valueCodec)
             );
             collection = db.getCollection(task.getCollection(), Value.class)
                     .withCodecRegistry(registry);
@@ -181,7 +213,44 @@ public class MongodbInputPlugin
 
         pageBuilder.finish();
 
-        return Exec.newTaskReport();
+        TaskReport report = Exec.newTaskReport();
+
+        if (valueCodec.getLastRecord() != null) {
+            DataSource lastRecord = new DataSourceImpl(Exec.getInjector().getInstance(ModelManager.class));
+            for (String k : valueCodec.getLastRecord().keySet()) {
+                String value = valueCodec.getLastRecord().get(k).toString();
+                Map<String, String> types = valueCodec.getLastRecordType();
+                HashMap<String, String> innerValue = new HashMap<>();
+                switch(types.get(k)) {
+                    case "OBJECT_ID":
+                        innerValue.put("$oid", value);
+                        lastRecord.set(k, innerValue);
+                        break;
+                    case "DATE_TIME":
+                        innerValue.put("$date", value);
+                        lastRecord.set(k, innerValue);
+                        break;
+                    case "INT32":
+                    case "INT64":
+                    case "TIMESTAMP":
+                        lastRecord.set(k, Integer.valueOf(value));
+                        break;
+                    case "BOOLEAN":
+                        lastRecord.set(k, Boolean.valueOf(value));
+                        break;
+                    case "DOUBLE":
+                        lastRecord.set(k, Double.valueOf(value));
+                        break;
+                    case "DOCUMENT":
+                    case "ARRAY":
+                        throw new ConfigException(String.format("Unsupported type '%s' was given for 'last_record' [%s]", types.get(k), value));
+                    default:
+                        lastRecord.set(k, value);
+                }
+            }
+            report.setNested("last_record", lastRecord);
+        }
+        return report;
     }
 
     @Override
@@ -201,6 +270,63 @@ public class MongodbInputPlugin
         return db;
     }
 
+    private Map<String, String> buildIncrementalCondition(PluginTask task)
+    {
+        Map<String, String> result = new HashMap<>();
+        String query = task.getQuery();
+        String sort = task.getSort();
+        result.put("query", query);
+        result.put("sort", sort);
+
+        Optional<List<String>> incrementalField = task.getIncrementalField();
+        Optional<Map<String, Object>> lastRecord = task.getLastRecord();
+        if (!incrementalField.isPresent()) {
+            return result;
+        }
+
+        Map<String, Object> newQuery = new LinkedHashMap<>();
+        Map<String, Integer> newSort = new LinkedHashMap<>();
+        ObjectMapper mapper = new ObjectMapper();
+
+        try {
+            @SuppressWarnings("unchecked")
+            Map<String, Object> queryJson = mapper.readValue(query, Map.class);
+            for (String k : queryJson.keySet()) {
+                newQuery.put(k, queryJson.get(k));
+            }
+
+            if (lastRecord.isPresent()) {
+                for (String k : lastRecord.get().keySet()) {
+                    Map<String, Object> v = new HashMap<>();
+                    Object record = lastRecord.get().get(k);
+
+                    if (newQuery.containsKey(k)) {
+                        throw new ConfigException("Field declaration was duplicated between 'incremental_field' and 'query' options");
+                    }
+
+                    v.put("$gt", record);
+                    newQuery.put(k, v);
+                }
+                String newQueryString = mapper.writeValueAsString(newQuery);
+                log.info(String.format("New query value was generated for incremental load: '%s'", newQueryString));
+                result.put("query", newQueryString);
+            }
+
+            for (String k : incrementalField.get()) {
+                newSort.put(k, 1);
+            }
+
+            String newSortString = mapper.writeValueAsString(newSort);
+            log.info(String.format("New sort value was generated for incremental load: '%s'", newSortString));
+            result.put("sort", newSortString);
+
+            return result;
+        }
+        catch (JSONParseException | IOException ex) {
+            throw new ConfigException("Could not generate new query for incremental load.");
+        }
+    }
+
     private void validateJsonField(String name, String jsonString)
     {
         try {

data/src/main/java/org/embulk/input/mongodb/ValueCodec.java

@@ -1,5 +1,6 @@
 package org.embulk.input.mongodb;
 
+import com.google.common.base.Optional;
 import org.bson.BsonReader;
 import org.bson.BsonType;
 import org.bson.BsonWriter;
@@ -14,12 +15,19 @@ import org.slf4j.Logger;
 import java.text.SimpleDateFormat;
 import java.util.ArrayList;
 import java.util.Date;
+import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.TimeZone;
-
-import static org.msgpack.value.ValueFactory.*;
+import static org.msgpack.value.ValueFactory.newArray;
+import static org.msgpack.value.ValueFactory.newBinary;
+import static org.msgpack.value.ValueFactory.newBoolean;
+import static org.msgpack.value.ValueFactory.newFloat;
+import static org.msgpack.value.ValueFactory.newInteger;
+import static org.msgpack.value.ValueFactory.newMap;
+import static org.msgpack.value.ValueFactory.newNil;
+import static org.msgpack.value.ValueFactory.newString;
 
 public class ValueCodec implements Codec<Value>
 {
@@ -27,6 +35,9 @@ public class ValueCodec implements Codec<Value>
     private final Logger log = Exec.getLogger(MongodbInputPlugin.class);
     private final boolean stopOnInvalidRecord;
     private final MongodbInputPlugin.PluginTask task;
+    private final Optional<List<String>> incrementalField;
+    private Map<String, Object> lastRecord;
+    private Map<String, String> lastRecordType;
 
     public ValueCodec(boolean stopOnInvalidRecord, MongodbInputPlugin.PluginTask task)
     {
@@ -34,6 +45,9 @@ public class ValueCodec implements Codec<Value>
         formatter.setTimeZone(TimeZone.getTimeZone("UTC"));
         this.stopOnInvalidRecord = stopOnInvalidRecord;
         this.task = task;
+        this.incrementalField = task.getIncrementalField();
+        this.lastRecord = new HashMap<>();
+        this.lastRecordType = new HashMap<>();
     }
 
     @Override
@@ -49,12 +63,18 @@ public class ValueCodec implements Codec<Value>
 
         reader.readStartDocument();
         while (reader.readBsonType() != BsonType.END_OF_DOCUMENT) {
-            String fieldName = reader.readName();
+            String originalFieldName = reader.readName();
             BsonType type = reader.getCurrentBsonType();
-            fieldName = normalize(fieldName);
+            String fieldName = normalize(originalFieldName);
 
+            Value value;
             try {
-                kvs.put(newString(fieldName), readValue(reader, decoderContext));
+                value = readValue(reader, decoderContext);
+                kvs.put(newString(fieldName), value);
+                if (incrementalField.isPresent() && incrementalField.get().contains(originalFieldName)) {
+                    this.lastRecord.put(originalFieldName, value);
+                    this.lastRecordType.put(originalFieldName, type.toString());
+                }
             }
             catch (UnknownTypeFoundException ex) {
                 reader.skipValue();
@@ -141,6 +161,16 @@ public class ValueCodec implements Codec<Value>
         return key;
     }
 
+    public Map<String, Object> getLastRecord()
+    {
+        return this.lastRecord;
+    }
+
+    public Map<String, String> getLastRecordType()
+    {
+        return this.lastRecordType;
+    }
+
     public static class UnknownTypeFoundException extends DataException
     {
         UnknownTypeFoundException(String message)

data/src/test/java/org/embulk/input/mongodb/TestMongodbInputPlugin.java

@@ -2,6 +2,7 @@ package org.embulk.input.mongodb;
 
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.base.Optional;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Lists;
 import com.mongodb.client.MongoCollection;
@@ -15,6 +16,7 @@ import org.bson.BsonTimestamp;
 import org.bson.Document;
 import org.bson.types.Symbol;
 import org.embulk.EmbulkTestRuntime;
+import org.embulk.config.ConfigDiff;
 import org.embulk.config.ConfigException;
 import org.embulk.config.ConfigSource;
 import org.embulk.config.TaskReport;
@@ -39,7 +41,9 @@ import java.text.DateFormat;
 import java.text.SimpleDateFormat;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.TimeZone;
 
 import static org.hamcrest.CoreMatchers.is;
@@ -93,6 +97,8 @@ public class TestMongodbInputPlugin
         assertEquals("{}", task.getSort());
         assertEquals((long) 10000, (long) task.getBatchSize());
         assertEquals("record", task.getJsonColumnName());
+        assertEquals(Optional.absent(), task.getIncrementalField());
+        assertEquals(Optional.absent(), task.getLastRecord());
     }
 
     @Test(expected = ConfigException.class)
@@ -125,6 +131,31 @@ public class TestMongodbInputPlugin
         plugin.transaction(config, new Control());
     }
 
+    @Test(expected = ConfigException.class)
+    public void checkInvalidOptionCombination()
+    {
+        ConfigSource config = Exec.newConfigSource()
+                .set("uri", MONGO_URI)
+                .set("collection", MONGO_COLLECTION)
+                .set("sort", "{ \"field1\": 1 }")
+                .set("incremental_field", Optional.of(Arrays.asList("account")));
+
+        plugin.transaction(config, new Control());
+    }
+
+    @Test(expected = ConfigException.class)
+    public void checkInvalidQueryOption()
+    {
+        ConfigSource config = Exec.newConfigSource()
+                .set("uri", MONGO_URI)
+                .set("collection", MONGO_COLLECTION)
+                .set("query", "{\"key\":invalid_value}")
+                .set("last_record", 0)
+                .set("incremental_field", Optional.of(Arrays.asList("account")));
+
+        plugin.transaction(config, new Control());
+    }
+
     @Test
     public void testResume()
     {
@@ -167,6 +198,44 @@ public class TestMongodbInputPlugin
         assertValidRecords(getFieldSchema(), output);
     }
 
+    @Test
+    public void testRunWithIncrementalLoad() throws Exception
+    {
+        ConfigSource config = Exec.newConfigSource()
+                .set("uri", MONGO_URI)
+                .set("collection", MONGO_COLLECTION)
+                .set("incremental_field", Optional.of(Arrays.asList("int32_field", "double_field", "datetime_field", "boolean_field")));
+        PluginTask task = config.loadConfig(PluginTask.class);
+
+        dropCollection(task, MONGO_COLLECTION);
+        createCollection(task, MONGO_COLLECTION);
+        insertDocument(task, createValidDocuments());
+
+        ConfigDiff diff = plugin.transaction(config, new Control());
+        ConfigDiff lastRecord = diff.getNested("last_record");
+
+        assertEquals("32864", lastRecord.get(String.class, "int32_field"));
+        assertEquals("1.23", lastRecord.get(String.class, "double_field"));
+        assertEquals("{$date=2015-01-27T10:23:49.000Z}", lastRecord.get(Map.class, "datetime_field").toString());
+        assertEquals("true", lastRecord.get(String.class, "boolean_field"));
+    }
+
+    @Test(expected = ConfigException.class)
+    public void testRunWithIncrementalLoadUnsupportedType() throws Exception
+    {
+        ConfigSource config = Exec.newConfigSource()
+                .set("uri", MONGO_URI)
+                .set("collection", MONGO_COLLECTION)
+                .set("incremental_field", Optional.of(Arrays.asList("document_field")));
+        PluginTask task = config.loadConfig(PluginTask.class);
+
+        dropCollection(task, MONGO_COLLECTION);
+        createCollection(task, MONGO_COLLECTION);
+        insertDocument(task, createValidDocuments());
+
+        plugin.transaction(config, new Control());
+    }
+
     @Test(expected = ValueCodec.UnknownTypeFoundException.class)
     public void testRunWithUnsupportedType() throws Exception
     {
@@ -229,6 +298,102 @@ public class TestMongodbInputPlugin
         }
     }
 
+    @Test
+    @SuppressWarnings("unchecked")
+    public void testBuildIncrementalCondition() throws Exception
+    {
+        PluginTask task = config().loadConfig(PluginTask.class);
+        dropCollection(task, MONGO_COLLECTION);
+        createCollection(task, MONGO_COLLECTION);
+        insertDocument(task, createValidDocuments());
+
+        Method method = MongodbInputPlugin.class.getDeclaredMethod("buildIncrementalCondition", PluginTask.class);
+        method.setAccessible(true);
+
+        ConfigSource config = Exec.newConfigSource()
+                .set("uri", MONGO_URI)
+                .set("collection", MONGO_COLLECTION)
+                .set("incremental_field", Optional.of(Arrays.asList("account")));
+        task = config.loadConfig(PluginTask.class);
+        Map<String, String> actual = (Map<String, String>) method.invoke(plugin, task);
+        Map<String, String> expected = new HashMap<>();
+        expected.put("query", "{}");
+        expected.put("sort", "{\"account\":1}");
+        assertEquals(expected, actual);
+
+        Map<String, Object> lastRecord = new HashMap<>();
+        Map<String, String> innerRecord = new HashMap<>();
+        innerRecord.put("$oid", "abc");
+        lastRecord.put("_id", innerRecord);
+        lastRecord.put("int32_field", 15000);
+        innerRecord = new HashMap<>();
+        innerRecord.put("$date", "2015-01-27T19:23:49Z");
+        lastRecord.put("datetime_field", innerRecord);
+        config = Exec.newConfigSource()
+                .set("uri", MONGO_URI)
+                .set("collection", MONGO_COLLECTION)
+                .set("query", "{\"double_field\":{\"$gte\": 1.23}}")
+                .set("incremental_field", Optional.of(Arrays.asList("_id", "int32_field", "datetime_field")))
+                .set("last_record", Optional.of(lastRecord));
+        task = config.loadConfig(PluginTask.class);
+        actual = (Map<String, String>) method.invoke(plugin, task);
+        expected.put("query", "{\"double_field\":{\"$gte\":1.23},\"int32_field\":{\"$gt\":15000},\"_id\":{\"$gt\":{\"$oid\":\"abc\"}},\"datetime_field\":{\"$gt\":{\"$date\":\"2015-01-27T19:23:49Z\"}}}");
+        expected.put("sort", "{\"_id\":1,\"int32_field\":1,\"datetime_field\":1}");
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testBuildIncrementalConditionFieldDuplicated() throws Exception
+    {
+        Map<String, Object> lastRecord = new HashMap<>();
+        lastRecord.put("double_field", "0");
+
+        ConfigSource config = Exec.newConfigSource()
+                .set("uri", MONGO_URI)
+                .set("collection", MONGO_COLLECTION)
+                .set("query", "{\"double_field\":{\"$gte\": 1.23}}")
+                .set("incremental_field", Optional.of(Arrays.asList("double_field")))
+                .set("last_record", Optional.of(lastRecord));
+        PluginTask task = config.loadConfig(PluginTask.class);
+        dropCollection(task, MONGO_COLLECTION);
+        createCollection(task, MONGO_COLLECTION);
+        insertDocument(task, createValidDocuments());
+
+        Method method = MongodbInputPlugin.class.getDeclaredMethod("buildIncrementalCondition", PluginTask.class);
+        method.setAccessible(true);
+        try {
+            method.invoke(plugin, task); // field declaration was duplicated between query and incremental_field
+        }
+        catch (Exception ex) {
+            assertEquals(ConfigException.class, ex.getCause().getClass());
+        }
+    }
+
+    @Test
+    public void testBuildIncrementalConditionFieldRequired() throws Exception
+    {
+        Map<String, Object> lastRecord = new HashMap<>();
+        lastRecord.put("double_field", "0");
+
+        ConfigSource config = Exec.newConfigSource()
+                .set("uri", MONGO_URI)
+                .set("collection", MONGO_COLLECTION)
+                .set("incremental_field", Optional.of(Arrays.asList("invalid_field")))
+                .set("last_record", Optional.of(lastRecord));
+        PluginTask task = config.loadConfig(PluginTask.class);
+        dropCollection(task, MONGO_COLLECTION);
+        createCollection(task, MONGO_COLLECTION);
+
+        Method method = MongodbInputPlugin.class.getDeclaredMethod("buildIncrementalCondition", PluginTask.class);
+        method.setAccessible(true);
+        try {
+            method.invoke(plugin, task); // field declaration was not set at incremental_field
+        }
+        catch (Exception ex) {
+            assertEquals(ConfigException.class, ex.getCause().getClass());
+        }
+    }
+
     static List<TaskReport> emptyTaskReports(int taskCount)
     {
         ImmutableList.Builder<TaskReport> reports = new ImmutableList.Builder<>();
@@ -376,7 +541,8 @@ public class TestMongodbInputPlugin
         collection.insertMany(documents);
     }
 
-    private DateFormat getUTCDateFormat() {
+    private DateFormat getUTCDateFormat()
+    {
       DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", java.util.Locale.ENGLISH);
       dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
       return dateFormat;

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: embulk-input-mongodb
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.0
 platform: ruby
 authors:
 - Kazuyuki Honda
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-06-23 00:00:00.000000000 Z
+date: 2016-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -67,7 +67,7 @@ files:
 - src/test/resources/id_field_name.yml
 - src/test/resources/id_field_name_expected.csv
 - src/test/resources/my_collection.jsonl
-- classpath/embulk-input-mongodb-0.3.2.jar
+- classpath/embulk-input-mongodb-0.4.0.jar
 - classpath/mongo-java-driver-3.2.2.jar
 homepage: https://github.com/hakobera/embulk-input-mongodb
 licenses: