embulk-filter-calcite 0.1.1 → 0.1.2

data/src/main/java/org/embulk/filter/calcite/adapter/page/PageEnumerator.java

@@ -6,49 +6,48 @@ import org.embulk.spi.Page;
 import org.embulk.spi.PageReader;
 import org.embulk.spi.Schema;
 
-public class PageEnumerator
-        implements Enumerator<Object[]>
-{
+public class PageEnumerator implements Enumerator<Object[]> {
+
     private final Schema schema;
     private final PageConverter pageConverter;
     private final PageReader pageReader;
 
-    public PageEnumerator(Schema schema, PageConverter pageConverter)
-    {
+    /**
+     * Creates an enumerator to read {@code Page} objects
+     *
+     * @param schema        a {@code Schema} that is used for reading {@code Page} objects.
+     * @param pageConverter a converter to translate values from Embulk types to Calcite types.
+     */
+    public PageEnumerator(Schema schema, PageConverter pageConverter) {
         this.schema = schema;
         this.pageReader = new PageReader(schema);
         this.pageConverter = pageConverter;
     }
 
-    public void setPage(Page page)
-    {
+    public void setPage(Page page) {
         this.pageReader.setPage(page);
         this.pageConverter.setPageReader(pageReader);
     }
 
     @Override
-    public Object[] current()
-    {
+    public Object[] current() {
         // this is called from org.apache.calcite.linq4j.EnumerableDefaults
         schema.visitColumns(pageConverter);
         return pageConverter.getRow();
     }
 
     @Override
-    public boolean moveNext()
-    {
+    public boolean moveNext() {
         return pageReader.nextRecord();
     }
 
     @Override
-    public void reset()
-    {
+    public void reset() {
         throw new UnsupportedOperationException();
     }
 
     @Override
-    public void close()
-    {
+    public void close() {
         if (pageReader != null) {
             pageReader.close();
         }

data/src/main/java/org/embulk/filter/calcite/adapter/page/PageFieldType.java

@@ -1,13 +1,11 @@
 package org.embulk.filter.calcite.adapter.page;
 
-import org.apache.calcite.adapter.java.JavaTypeFactory;
-import org.apache.calcite.rel.type.RelDataType;
-
 import java.util.HashMap;
 import java.util.Map;
+import org.apache.calcite.adapter.java.JavaTypeFactory;
+import org.apache.calcite.rel.type.RelDataType;
 
-enum PageFieldType
-{
+enum PageFieldType {
     STRING(String.class, "string"),
     BOOLEAN(Boolean.class, Boolean.TYPE.getSimpleName()),
     LONG(Long.class, Long.TYPE.getSimpleName()),
@@ -16,8 +14,7 @@ enum PageFieldType
 
     private static final Map<String, PageFieldType> MAP = new HashMap<>();
 
-    static
-    {
+    static {
         for (PageFieldType value : values()) {
             MAP.put(value.simpleName, value);
         }
@@ -26,19 +23,16 @@ enum PageFieldType
     private final Class clazz;
     private final String simpleName;
 
-    private PageFieldType(Class clazz, String simpleName)
-    {
+    private PageFieldType(Class clazz, String simpleName) {
         this.clazz = clazz;
         this.simpleName = simpleName;
     }
 
-    public RelDataType toType(JavaTypeFactory typeFactory)
-    {
-        return typeFactory.createJavaType(clazz);
+    public static PageFieldType of(String typeString) {
+        return MAP.get(typeString);
     }
 
-    public static PageFieldType of(String typeString)
-    {
-        return MAP.get(typeString);
+    public RelDataType toType(JavaTypeFactory typeFactory) {
+        return typeFactory.createJavaType(clazz);
     }
 }

data/src/main/java/org/embulk/filter/calcite/adapter/page/PageSchema.java

@@ -1,26 +1,21 @@
 package org.embulk.filter.calcite.adapter.page;
 
 import com.google.common.collect.ImmutableMap;
+import java.util.Map;
 import org.apache.calcite.schema.Table;
 import org.apache.calcite.schema.impl.AbstractSchema;
-import org.embulk.filter.calcite.PageConverter;
 import org.embulk.spi.Schema;
 
-import java.util.Map;
+public class PageSchema extends AbstractSchema {
 
-public class PageSchema
-        extends AbstractSchema
-{
     public static Schema schema;
 
-    public PageSchema()
-    {
+    public PageSchema() {
         super();
     }
 
     @Override
-    protected Map<String, Table> getTableMap()
-    {
+    protected Map<String, Table> getTableMap() {
         return ImmutableMap.<String, Table>of("$PAGES", new PageTable(schema, null));
     }
 }

data/src/main/java/org/embulk/filter/calcite/adapter/page/PageSchemaFactory.java

@@ -1,26 +1,25 @@
 package org.embulk.filter.calcite.adapter.page;
 
+import java.util.Map;
 import org.apache.calcite.schema.SchemaFactory;
 import org.apache.calcite.schema.SchemaPlus;
 
-import java.util.Map;
-
 /**
  * Factory that creates a {@link PageSchema}.
+ *
  * @see https://github.com/apache/calcite/blob/master/example/csv/src/main/java/org/apache/calcite/adapter/csv/CsvSchemaFactory.java
  */
 public class PageSchemaFactory
-        implements SchemaFactory
-{
+        implements SchemaFactory {
+
     public static final PageSchemaFactory INSTANCE = new PageSchemaFactory();
 
-    private PageSchemaFactory()
-    {
+    private PageSchemaFactory() {
     }
 
     @Override
-    public org.apache.calcite.schema.Schema create(SchemaPlus parentSchema, String name, Map<String, Object> operand)
-    {
+    public org.apache.calcite.schema.Schema create(SchemaPlus parentSchema, String name,
+                                                   Map<String, Object> operand) {
         return new PageSchema();
     }
 }

data/src/main/java/org/embulk/filter/calcite/adapter/page/PageTable.java

@@ -1,5 +1,7 @@
 package org.embulk.filter.calcite.adapter.page;
 
+import java.util.ArrayList;
+import java.util.List;
 import org.apache.calcite.DataContext;
 import org.apache.calcite.adapter.java.JavaTypeFactory;
 import org.apache.calcite.linq4j.AbstractEnumerable;
@@ -16,27 +18,29 @@ import org.embulk.spi.Column;
 import org.embulk.spi.Page;
 import org.embulk.spi.Schema;
 
-import java.util.ArrayList;
-import java.util.List;
+/**
+ * Base class for table that reads Pages.
+ */
+public class PageTable extends AbstractTable implements ScannableTable {
 
-public class PageTable
-        extends AbstractTable
-        implements ScannableTable
-{
     public static ThreadLocal<PageConverter> pageConverter = new ThreadLocal<>();
     public static ThreadLocal<Page> page = new ThreadLocal<>();
 
     private final Schema schema;
     private final RelProtoDataType protoRowType;
 
-    PageTable(Schema schema, RelProtoDataType protoRowType)
-    {
+    // Creates a {@code PageTable} object.
+    PageTable(Schema schema, RelProtoDataType protoRowType) {
         this.schema = schema;
         this.protoRowType = protoRowType;
     }
 
-    public RelDataType getRowType(RelDataTypeFactory typeFactory)
-    {
+    /**
+     * Returns a {@code RelDataType} by a given {@code RelDataTypeFactory}.
+     *
+     * @param typeFactory a factory object to create {code RelDataType}s.
+     */
+    public RelDataType getRowType(RelDataTypeFactory typeFactory) {
         if (protoRowType != null) {
             return protoRowType.apply(typeFactory);
         }
@@ -53,11 +57,16 @@ public class PageTable
         return typeFactory.createStructType(Pair.zip(names, types));
     }
 
-    public Enumerable<Object[]> scan(DataContext root)
-    {
+    /**
+     * Creates and returns a {@code Enumerable} object to read a {@code Page} object.
+     *
+     * @param root a {@code DataContext} object that can be used during scanning a {@code Page}
+     *             object.
+     * @return a {@code Enumerable} object
+     */
+    public Enumerable<Object[]> scan(DataContext root) {
         return new AbstractEnumerable<Object[]>() {
-            public Enumerator<Object[]> enumerator()
-            {
+            public Enumerator<Object[]> enumerator() {
                 PageEnumerator enumerator = new PageEnumerator(schema, pageConverter.get());
                 if (page.get() != null) {
                     enumerator.setPage(page.get());

data/src/main/java/org/embulk/filter/calcite/getter/FilterColumnGetterFactory.java

@@ -11,25 +11,37 @@ import org.embulk.spi.type.Type;
 import org.joda.time.DateTimeZone;
 
 public class FilterColumnGetterFactory
-        extends ColumnGetterFactory
-{
+        extends ColumnGetterFactory {
+
     private final DateTimeZone defaultTimeZone;
 
-    public FilterColumnGetterFactory(PageBuilder to, DateTimeZone defaultTimeZone)
-    {
+    /**
+     * Creates a factory object to create {@code ColumnGetter}s for converting JdbcType to Embulk
+     * type.
+     *
+     * @param to              a {@code PageBuilder} object that is passed to column getters.
+     * @param defaultTimeZone a {@code DateTimeZone} object passed to timestamp column getters as
+     *                        default.
+     */
+    public FilterColumnGetterFactory(PageBuilder to, DateTimeZone defaultTimeZone) {
         super(to, defaultTimeZone);
-        this.defaultTimeZone = defaultTimeZone; // TODO make change super.defaultTimeZone field protected
+        // TODO make change super.defaultTimeZone field protected
+        this.defaultTimeZone = defaultTimeZone;
     }
 
     @Override
-    public ColumnGetter newColumnGetter(JdbcInputConnection con, AbstractJdbcInputPlugin.PluginTask task, JdbcColumn column, JdbcColumnOption option)
-    {
+    public ColumnGetter newColumnGetter(JdbcInputConnection con,
+                                        AbstractJdbcInputPlugin.PluginTask task,
+                                        JdbcColumn column,
+                                        JdbcColumnOption option) {
         String valueType = option.getValueType();
         Type toType = getToType(option);
-        if (valueType.equals("coalesce") && sqlTypeToValueType(column, column.getSqlType()).equals("timestamp")) {
-            return new FilterTimestampColumnGetter(to, toType, option.getTimeZone().or(defaultTimeZone));
-        }
-        else {
+        if (valueType.equals("coalesce") && sqlTypeToValueType(column, column.getSqlType())
+                .equals("timestamp")) {
+            return new FilterTimestampColumnGetter(to,
+                    toType,
+                    option.getTimeZone().or(defaultTimeZone));
+        } else {
             return super.newColumnGetter(con, task, column, option);
         }
     }

data/src/main/java/org/embulk/filter/calcite/getter/FilterTimestampColumnGetter.java

@@ -1,33 +1,29 @@
 package org.embulk.filter.calcite.getter;
 
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.Calendar;
+import java.util.TimeZone;
+
 import org.embulk.input.jdbc.getter.TimestampColumnGetter;
 import org.embulk.spi.PageBuilder;
 import org.embulk.spi.time.Timestamp;
 import org.embulk.spi.type.Type;
 import org.joda.time.DateTimeZone;
 
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.util.Calendar;
-
-import static java.util.Calendar.getInstance;
-import static java.util.TimeZone.getTimeZone;
-
 public class FilterTimestampColumnGetter
-        extends TimestampColumnGetter
-{
+        extends TimestampColumnGetter {
+
     private static final ThreadLocal<Calendar> calendar = new ThreadLocal<>();
 
-    public FilterTimestampColumnGetter(PageBuilder to, Type toType, DateTimeZone timeZone)
-    {
+    public FilterTimestampColumnGetter(PageBuilder to, Type toType, DateTimeZone timeZone) {
         super(to, toType, null);
-        calendar.set(getInstance(getTimeZone(timeZone.getID()))); // set TLS here
+        calendar.set(Calendar.getInstance(TimeZone.getTimeZone(timeZone.getID()))); // set TLS here
     }
 
     @Override
     protected void fetch(ResultSet from, int fromIndex)
-            throws SQLException
-    {
+            throws SQLException {
         java.sql.Timestamp timestamp = from.getTimestamp(fromIndex, calendar.get());
         if (timestamp != null) {
             value = Timestamp.ofEpochSecond(timestamp.getTime() / 1000, timestamp.getNanos());

data/src/test/java/org/embulk/filter/calcite/TestCalciteFilterPlugin.java

@@ -1,24 +1,20 @@
 package org.embulk.filter.calcite;
 
 import com.google.common.collect.ImmutableList;
+import java.io.IOException;
+import java.nio.file.Path;
 import org.embulk.config.ConfigSource;
 import org.embulk.spi.FilterPlugin;
+import org.embulk.test.EmbulkTests;
 import org.embulk.test.TestingEmbulk;
+import org.hamcrest.Matchers;
+import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 
-import java.io.IOException;
-import java.nio.file.Path;
-
-import static org.embulk.test.EmbulkTests.copyResource;
-import static org.embulk.test.EmbulkTests.readResource;
-import static org.embulk.test.EmbulkTests.readSortedFile;
-import static org.hamcrest.Matchers.is;
-import static org.junit.Assert.assertThat;
+public class TestCalciteFilterPlugin {
 
-public class TestCalciteFilterPlugin
-{
     private static final String RESOURCE_NAME_PREFIX = "org/embulk/filter/calcite/test/";
 
     @Rule
@@ -28,69 +24,99 @@ public class TestCalciteFilterPlugin
 
     private ConfigSource baseConfig;
 
+    static void assertRecordsByResource(TestingEmbulk embulk,
+                                        String inConfigYamlResourceName,
+                                        String filterConfigYamlResourceName,
+                                        String sourceCsvResourceName,
+                                        String resultCsvResourceName)
+            throws IOException {
+        Path inputPath = embulk.createTempFile("csv");
+        Path outputPath = embulk.createTempFile("csv");
+
+        // in: config
+        EmbulkTests.copyResource(RESOURCE_NAME_PREFIX + sourceCsvResourceName, inputPath);
+        ConfigSource inConfig = embulk.loadYamlResource(
+                RESOURCE_NAME_PREFIX + inConfigYamlResourceName)
+                .set("path_prefix", inputPath.toAbsolutePath().toString());
+
+        // remove_columns filter config
+        ConfigSource filterConfig = embulk
+                .loadYamlResource(RESOURCE_NAME_PREFIX + filterConfigYamlResourceName);
+
+        TestingEmbulk.RunResult result = embulk.inputBuilder()
+                .in(inConfig)
+                .filters(ImmutableList.of(filterConfig))
+                .outputPath(outputPath)
+                .run();
+
+        Assert.assertThat(EmbulkTests.readSortedFile(outputPath),
+                Matchers.is(EmbulkTests.readResource(
+                        RESOURCE_NAME_PREFIX + resultCsvResourceName)));
+    }
+
     @Before
-    public void setup()
-    {
+    public void setup() {
         baseConfig = embulk.newConfig();
     }
 
     @Test
-    public void testSimple() throws Exception
-    {
-        assertRecordsByResource(embulk, "test_simple_in.yml", "test_simple_filter.yml",
-                "test_simple_source.csv", "test_simple_expected.csv");
+    public void testSimple() throws Exception {
+        assertRecordsByResource(embulk,
+                "test_simple_in.yml",
+                "test_simple_filter.yml",
+                "test_simple_source.csv",
+                "test_simple_expected.csv");
     }
 
+    /**
+     * This method was added to confirm #13 is fixed or not.
+     *
+     * @throws Exception
+     *
+     * @see https://github.com/muga/embulk-filter-calcite/issues/13
+     * @see https://issues.apache.org/jira/browse/CALCITE-1673
+     */
     @Test
-    public void testIntOperators() throws Exception
-    {
-        assertRecordsByResource(embulk, "test_int_ops_in.yml", "test_int_ops_filter.yml",
-                "test_int_ops_source.csv", "test_int_ops_expected.csv");
+    public void testTimestampConversion() throws Exception {
+        assertRecordsByResource(embulk, "test_timestamp_conv_in.yml",
+                "test_timestamp_conv_filter.yml",
+                "test_timestamp_conv_source.csv",
+                "test_timestamp_conv_expected.csv");
     }
 
     @Test
-    public void testWhereIntCondition() throws Exception
-    {
-        assertRecordsByResource(embulk, "test_where_int_cond_in.yml", "test_where_int_cond_filter.yml",
-                "test_where_int_cond_source.csv", "test_where_int_cond_expected.csv");
+    public void testIntOperators() throws Exception {
+        assertRecordsByResource(embulk,
+                "test_int_ops_in.yml",
+                "test_int_ops_filter.yml",
+                "test_int_ops_source.csv",
+                "test_int_ops_expected.csv");
     }
 
     @Test
-    public void testStringOperators() throws Exception
-    {
-        assertRecordsByResource(embulk, "test_string_ops_in.yml", "test_string_ops_filter.yml",
-                "test_string_ops_source.csv", "test_string_ops_expected.csv");
+    public void testWhereIntCondition() throws Exception {
+        assertRecordsByResource(embulk,
+                "test_where_int_cond_in.yml",
+                "test_where_int_cond_filter.yml",
+                "test_where_int_cond_source.csv",
+                "test_where_int_cond_expected.csv");
     }
 
     @Test
-    public void testWhereStringCondition() throws Exception
-    {
-        assertRecordsByResource(embulk, "test_where_string_cond_in.yml", "test_where_string_cond_filter.yml",
-                "test_where_string_cond_source.csv", "test_where_string_cond_expected.csv");
+    public void testStringOperators() throws Exception {
+        assertRecordsByResource(embulk,
+                "test_string_ops_in.yml",
+                "test_string_ops_filter.yml",
+                "test_string_ops_source.csv",
+                "test_string_ops_expected.csv");
     }
 
-    static void assertRecordsByResource(TestingEmbulk embulk,
-            String inConfigYamlResourceName, String filterConfigYamlResourceName,
-            String sourceCsvResourceName, String resultCsvResourceName)
-            throws IOException
-    {
-        Path inputPath = embulk.createTempFile("csv");
-        Path outputPath = embulk.createTempFile("csv");
-
-        // in: config
-        copyResource(RESOURCE_NAME_PREFIX + sourceCsvResourceName, inputPath);
-        ConfigSource inConfig = embulk.loadYamlResource(RESOURCE_NAME_PREFIX + inConfigYamlResourceName)
-                .set("path_prefix", inputPath.toAbsolutePath().toString());
-
-        // remove_columns filter config
-        ConfigSource filterConfig = embulk.loadYamlResource(RESOURCE_NAME_PREFIX + filterConfigYamlResourceName);
-
-        TestingEmbulk.RunResult result = embulk.inputBuilder()
-                .in(inConfig)
-                .filters(ImmutableList.of(filterConfig))
-                .outputPath(outputPath)
-                .run();
-
-        assertThat(readSortedFile(outputPath), is(readResource(RESOURCE_NAME_PREFIX + resultCsvResourceName)));
+    @Test
+    public void testWhereStringCondition() throws Exception {
+        assertRecordsByResource(embulk,
+                "test_where_string_cond_in.yml",
+                "test_where_string_cond_filter.yml",
+                "test_where_string_cond_source.csv",
+                "test_where_string_cond_expected.csv");
     }
 }