embulk-filter-row 0.1.0

data/src/main/java/org/embulk/filter/row/TimestampCondition.java

@@ -0,0 +1,64 @@
+package org.embulk.filter.row;
+import org.embulk.spi.time.Timestamp;
+
+public class TimestampCondition implements Condition
+{
+    private TimestampComparator comparator;
+
+    @FunctionalInterface
+    interface TimestampComparator {
+        boolean compare(Timestamp subject);
+    }
+
+    public TimestampCondition(String operator, Timestamp argument, boolean not) {
+        TimestampComparator comparator;
+        switch (operator.toUpperCase()) {
+            case ">":
+                comparator = (Timestamp subject) -> {
+                    return subject == null ? false : subject.compareTo(argument) > 0;
+                };
+                break;
+            case ">=":
+                comparator = (Timestamp subject) -> {
+                    return subject == null ? false : subject.compareTo(argument) >= 0;
+                };
+                break;
+            case "<":
+                comparator = (Timestamp subject) -> {
+                    return subject == null ? false : subject.compareTo(argument) < 0;
+                };
+                break;
+            case "<=":
+                comparator = (Timestamp subject) -> {
+                    return subject == null ? false : subject.compareTo(argument) <= 0;
+                };
+                break;
+            case "IS NULL":
+                comparator = (Timestamp subject) -> {
+                    return subject == null;
+                };
+                break;
+            case "IS NOT NULL":
+                comparator = (Timestamp subject) -> {
+                    return subject != null;
+                };
+                break;
+            case "!=":
+                comparator = (Timestamp subject) -> {
+                    return subject == null ? true : !subject.equals(argument);
+                };
+                break;
+            default: // case "==":
+                comparator = (Timestamp subject) -> {
+                    return subject == null ? false : subject.equals(argument);
+                };
+                break;
+        }
+        this.comparator = comparator;
+        if (not) this.comparator = (Timestamp subject) -> { return !comparator.compare(subject); };
+    }
+
+    public boolean compare(Timestamp subject) {
+        return this.comparator.compare(subject);
+    }
+}

data/src/test/java/org/embulk/filter/TestRowFilterPlugin.java

@@ -0,0 +1,5 @@
+package org.embulk.filter;
+
+public class TestRowFilterPlugin
+{
+}

data/src/test/java/org/embulk/filter/row/TestBooleanCondition.java

@@ -0,0 +1,64 @@
+package org.embulk.filter.row;
+
+import org.embulk.filter.row.BooleanCondition;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class TestBooleanCondition
+{
+    @Test
+    public void testIsNull() {
+        BooleanCondition condition = new BooleanCondition("IS NULL", null, false);
+        assertTrue(condition.compare(null));
+        assertFalse(condition.compare(new Boolean(true)));
+        assertFalse(condition.compare(new Boolean(false)));
+    }
+
+    @Test
+    public void testIsNotNull() {
+        BooleanCondition condition = new BooleanCondition("IS NOT NULL", null, false);
+        assertFalse(condition.compare(null));
+        assertTrue(condition.compare(new Boolean(true)));
+        assertTrue(condition.compare(new Boolean(false)));
+    }
+
+    @Test
+    public void testNot() {
+        BooleanCondition condition = new BooleanCondition("IS NOT NULL", null, true);
+        assertTrue(condition.compare(null));
+        assertFalse(condition.compare(new Boolean(true)));
+        assertFalse(condition.compare(new Boolean(false)));
+    }
+
+    @Test
+    public void testEquals() {
+        BooleanCondition condition = new BooleanCondition("==", new Boolean(true), false);
+        assertTrue(condition.compare(new Boolean(true)));
+        assertFalse(condition.compare(new Boolean(false)));
+        assertFalse(condition.compare(null));
+
+        condition = new BooleanCondition("==", new Boolean(false), false);
+        assertTrue(condition.compare(new Boolean(false)));
+        assertFalse(condition.compare(new Boolean(true)));
+        assertFalse(condition.compare(null));
+
+        // Prohibited by Factory
+        // BooleanCondition condition = new BooleanCondition("==", null, false);
+    }
+
+    @Test
+    public void testNotEquals() {
+        BooleanCondition condition = new BooleanCondition("!=", new Boolean(true), false);
+        assertFalse(condition.compare(new Boolean(true)));
+        assertTrue(condition.compare(new Boolean(false)));
+        assertTrue(condition.compare(null));
+
+        condition = new BooleanCondition("!=", new Boolean(false), false);
+        assertFalse(condition.compare(new Boolean(false)));
+        assertTrue(condition.compare(new Boolean(true)));
+        assertTrue(condition.compare(null));
+
+        // Prohibited by Factory
+        // BooleanCondition condition = new BooleanCondition("!=", null, false);
+    }
+}

data/src/test/java/org/embulk/filter/row/TestConditionFactory.java

@@ -0,0 +1,250 @@
+package org.embulk.filter.row;
+
+import org.embulk.spi.Column;
+import org.embulk.spi.type.Type;
+import static org.embulk.spi.type.Types.*;
+import org.embulk.spi.type.BooleanType;
+import org.embulk.spi.type.LongType;
+import org.embulk.spi.type.DoubleType;
+import org.embulk.spi.type.StringType;
+import org.embulk.spi.type.TimestampType;
+import org.embulk.spi.time.Timestamp;
+import org.embulk.config.ConfigException;
+import org.embulk.config.TaskSource;
+
+import org.embulk.filter.row.ConditionConfig;
+import org.embulk.filter.row.ConditionFactory;
+import org.embulk.filter.row.BooleanCondition;
+import org.embulk.filter.row.DoubleCondition;
+import org.embulk.filter.row.Condition;
+import org.embulk.filter.row.StringCondition;
+import org.embulk.filter.row.TimestampCondition;
+
+import com.google.common.base.Optional;
+import org.jruby.embed.ScriptingContainer;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import java.lang.NullPointerException;
+
+public class TestConditionFactory
+{
+    public class DefaultConditionConfig implements ConditionConfig
+    {
+        public String getColumn()             { return "column"; }
+        public Optional<String> getOperator() { return Optional.of("IS NULL"); }
+        public Optional<Object> getArgument() { return Optional.absent(); }
+        public Optional<Boolean> getNot()     { return Optional.of(false); }
+        public Optional<String> getFormat()   { return Optional.of("%Y-%m-%d"); }
+        public Optional<String> getTimezone() { return Optional.of("UTC"); }
+        public TaskSource dump()              { return null; }
+        public void validate()                {}
+    }
+
+    private final ScriptingContainer jruby;
+
+    public TestConditionFactory()
+    {
+        jruby = new ScriptingContainer();
+    }
+
+    @Test
+    public void testCreateBooleanCondition() {
+        Column column = new Column(0, "column", BOOLEAN);
+        ConditionConfig  config;
+        BooleanCondition condition;
+
+        config = new DefaultConditionConfig() {
+            public Optional<String> getOperator() { return Optional.of("IS NULL"); }
+        };
+        condition = (BooleanCondition)new ConditionFactory(jruby, column, config).createCondition();
+        assertTrue(condition.compare(null));
+
+        config = new DefaultConditionConfig() {
+            public Optional<String> getOperator() { return Optional.of("=="); }
+            public Optional<Object> getArgument() { return Optional.absent(); }
+        };
+        try {
+            condition = (BooleanCondition)new ConditionFactory(jruby, column, config).createCondition();
+            fail("Argument is required");
+        } catch (ConfigException e) {
+        }
+
+        config = new DefaultConditionConfig() {
+            public Optional<String> getOperator() { return Optional.of("=="); }
+            public Optional<Object> getArgument() { return Optional.of(new Boolean(true)); }
+        };
+        condition = (BooleanCondition)new ConditionFactory(jruby, column, config).createCondition();
+        assertTrue(condition.compare(new Boolean(true)));
+
+        config = new DefaultConditionConfig() {
+            public Optional<String> getOperator() { return Optional.of("=="); }
+            public Optional<Object> getArgument() { return Optional.of(new Long(10)); }
+        };
+        try {
+            condition = (BooleanCondition)new ConditionFactory(jruby, column, config).createCondition();
+            fail("Argument type mismatch");
+        } catch (ConfigException e) {
+        }
+    }
+
+    @Test
+    public void testCreateDoubleCondition() {
+        Column column = new Column(0, "column", DOUBLE);
+        ConditionConfig  config;
+        DoubleCondition condition;
+
+        config = new DefaultConditionConfig() {
+            public Optional<String> getOperator() { return Optional.of("IS NULL"); }
+        };
+        condition = (DoubleCondition)new ConditionFactory(jruby, column, config).createCondition();
+        assertTrue(condition.compare(null));
+
+        config = new DefaultConditionConfig() {
+            public Optional<String> getOperator() { return Optional.of("=="); }
+            public Optional<Object> getArgument() { return Optional.absent(); }
+        };
+        try {
+            condition = (DoubleCondition)new ConditionFactory(jruby, column, config).createCondition();
+            fail("Argument is required");
+        } catch (ConfigException e) {
+        }
+
+        config = new DefaultConditionConfig() {
+            public Optional<String> getOperator() { return Optional.of("=="); }
+            public Optional<Object> getArgument() { return Optional.of(new Double(10)); }
+        };
+        condition = (DoubleCondition)new ConditionFactory(jruby, column, config).createCondition();
+        assertTrue(condition.compare(new Double(10)));
+
+        config = new DefaultConditionConfig() {
+            public Optional<String> getOperator() { return Optional.of("=="); }
+            public Optional<Object> getArgument() { return Optional.of(new Boolean(true)); }
+        };
+        try {
+            condition = (DoubleCondition)new ConditionFactory(jruby, column, config).createCondition();
+            fail("Argument type mismatch");
+        } catch (ConfigException e) {
+        }
+    }
+
+    @Test
+    public void testCreateLongCondition() {
+        Column column = new Column(0, "column", LONG);
+        ConditionConfig  config;
+        LongCondition condition;
+
+        config = new DefaultConditionConfig() {
+            public Optional<String> getOperator() { return Optional.of("IS NULL"); }
+        };
+        condition = (LongCondition)new ConditionFactory(jruby, column, config).createCondition();
+        assertTrue(condition.compare(null));
+
+        config = new DefaultConditionConfig() {
+            public Optional<String> getOperator() { return Optional.of("=="); }
+            public Optional<Object> getArgument() { return Optional.absent(); }
+        };
+        try {
+            condition = (LongCondition)new ConditionFactory(jruby, column, config).createCondition();
+            fail("Argument is required");
+        } catch (ConfigException e) {
+        }
+
+        config = new DefaultConditionConfig() {
+            public Optional<String> getOperator() { return Optional.of("=="); }
+            public Optional<Object> getArgument() { return Optional.of(new Long(10)); }
+        };
+        condition = (LongCondition)new ConditionFactory(jruby, column, config).createCondition();
+        assertTrue(condition.compare(new Long(10)));
+
+        config = new DefaultConditionConfig() {
+            public Optional<String> getOperator() { return Optional.of("=="); }
+            public Optional<Object> getArgument() { return Optional.of(new Boolean(true)); }
+        };
+        try {
+            condition = (LongCondition)new ConditionFactory(jruby, column, config).createCondition();
+            fail("Argument type mismatch");
+        } catch (ConfigException e) {
+        }
+    }
+
+    @Test
+    public void testCreateStringCondition() {
+        Column column = new Column(0, "column", STRING);
+        ConditionConfig  config;
+        StringCondition condition;
+
+        config = new DefaultConditionConfig() {
+            public Optional<String> getOperator() { return Optional.of("IS NULL"); }
+        };
+        condition = (StringCondition)new ConditionFactory(jruby, column, config).createCondition();
+        assertTrue(condition.compare(null));
+
+        config = new DefaultConditionConfig() {
+            public Optional<String> getOperator() { return Optional.of("=="); }
+            public Optional<Object> getArgument() { return Optional.absent(); }
+        };
+        try {
+            condition = (StringCondition)new ConditionFactory(jruby, column, config).createCondition();
+            fail("Argument is required");
+        } catch (ConfigException e) {
+        }
+
+        config = new DefaultConditionConfig() {
+            public Optional<String> getOperator() { return Optional.of("=="); }
+            public Optional<Object> getArgument() { return Optional.of("foo"); }
+        };
+        condition = (StringCondition)new ConditionFactory(jruby, column, config).createCondition();
+        assertTrue(condition.compare("foo"));
+
+        config = new DefaultConditionConfig() {
+            public Optional<String> getOperator() { return Optional.of("=="); }
+            public Optional<Object> getArgument() { return Optional.of(new Boolean(true)); }
+        };
+        try {
+            condition = (StringCondition)new ConditionFactory(jruby, column, config).createCondition();
+            fail("Argument type mismatch");
+        } catch (ConfigException e) {
+        }
+    }
+
+    @Test
+    public void testCreateTimestampCondition() {
+        Column column = new Column(0, "column", TIMESTAMP);
+        ConditionConfig  config;
+        TimestampCondition condition;
+
+        config = new DefaultConditionConfig() {
+            public Optional<String> getOperator() { return Optional.of("IS NULL"); }
+        };
+        condition = (TimestampCondition)new ConditionFactory(jruby, column, config).createCondition();
+        assertTrue(condition.compare(null));
+
+        config = new DefaultConditionConfig() {
+            public Optional<String> getOperator() { return Optional.of("=="); }
+            public Optional<Object> getArgument() { return Optional.absent(); }
+        };
+        try {
+            condition = (TimestampCondition)new ConditionFactory(jruby, column, config).createCondition();
+            fail("Argument is required");
+        } catch (ConfigException e) {
+        }
+
+        //ToDo: How to create jruby object correctly?
+        //config = new DefaultConditionConfig() {
+        //    public Optional<String> getOperator() { return Optional.of("=="); }
+        //    public Optional<Object> getArgument() { return Optional.of("2015-07-15"); }
+        //    public Optional<String> getFormat()   { return Optional.of("%Y-%m-%d"); }
+        //};
+        //condition = (TimestampCondition)new ConditionFactory(jruby, column, config).createCondition();
+
+        config = new DefaultConditionConfig() {
+            public Optional<String> getOperator() { return Optional.of("=="); }
+            public Optional<Object> getArgument() { return Optional.of(new Boolean(true)); }
+        };
+        try {
+            condition = (TimestampCondition)new ConditionFactory(jruby, column, config).createCondition();
+            fail("Argument type mismatch");
+        } catch (ConfigException e) {
+        }
+    }
+}

data/src/test/java/org/embulk/filter/row/TestDoubleCondition.java

@@ -0,0 +1,81 @@
+package org.embulk.filter.row;
+
+import org.embulk.filter.row.DoubleCondition;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class TestDoubleCondition
+{
+    @Test
+    public void testIsNull() {
+        DoubleCondition condition = new DoubleCondition("IS NULL", null, false);
+        assertTrue(condition.compare(null));
+        assertFalse(condition.compare(new Double(10)));
+    }
+
+    @Test
+    public void testIsNotNull() {
+        DoubleCondition condition = new DoubleCondition("IS NOT NULL", null, false);
+        assertFalse(condition.compare(null));
+        assertTrue(condition.compare(new Double(10)));
+    }
+
+    @Test
+    public void testEquals() {
+        DoubleCondition condition = new DoubleCondition("==", new Double(10), false);
+        assertFalse(condition.compare(null));
+        assertTrue( condition.compare(new Double(10)));
+        assertFalse(condition.compare(new Double(11)));
+
+        // Prohibited by Factory
+        // DoubleCondition condition = new DoubleCondition("==", null, false);
+    }
+
+    @Test
+    public void testNotEquals() {
+        DoubleCondition condition = new DoubleCondition("!=", new Double(10), false);
+        assertTrue( condition.compare(null));
+        assertFalse(condition.compare(new Double(10)));
+        assertTrue( condition.compare(new Double(11)));
+    }
+
+    @Test
+    public void testGreaterThan() {
+        DoubleCondition condition = new DoubleCondition(">", new Double(10), false);
+        assertFalse(condition.compare(null));
+        assertFalse(condition.compare(new Double(10)));
+        assertTrue( condition.compare(new Double(11)));
+    }
+
+    @Test
+    public void testGreaterEqual() {
+        DoubleCondition condition = new DoubleCondition(">=", new Double(11), false);
+        assertFalse(condition.compare(null));
+        assertFalse(condition.compare(new Double(10)));
+        assertTrue( condition.compare(new Double(11)));
+    }
+
+    @Test
+    public void testLessThan() {
+        DoubleCondition condition = new DoubleCondition("<", new Double(11), false);
+        assertFalse(condition.compare(null));
+        assertFalse(condition.compare(new Double(11)));
+        assertTrue( condition.compare(new Double(10)));
+    }
+
+    @Test
+    public void testLessEqual() {
+        DoubleCondition condition = new DoubleCondition("<=", new Double(11), false);
+        assertFalse(condition.compare(null));
+        assertFalse(condition.compare(new Double(12)));
+        assertTrue( condition.compare(new Double(11)));
+    }
+
+    @Test
+    public void testNot() {
+        DoubleCondition condition = new DoubleCondition("<=", new Double(11), true);
+        assertTrue( condition.compare(null));
+        assertTrue( condition.compare(new Double(12)));
+        assertFalse(condition.compare(new Double(11)));
+    }
+}

data/src/test/java/org/embulk/filter/row/TestLongCondition.java

@@ -0,0 +1,81 @@
+package org.embulk.filter.row;
+
+import org.embulk.filter.row.LongCondition;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class TestLongCondition
+{
+    @Test
+    public void testIsNull() {
+        LongCondition condition = new LongCondition("IS NULL", null, false);
+        assertTrue(condition.compare(null));
+        assertFalse(condition.compare(new Long(10)));
+    }
+
+    @Test
+    public void testIsNotNull() {
+        LongCondition condition = new LongCondition("IS NOT NULL", null, false);
+        assertFalse(condition.compare(null));
+        assertTrue(condition.compare(new Long(10)));
+    }
+
+    @Test
+    public void testEquals() {
+        LongCondition condition = new LongCondition("==", new Long(10), false);
+        assertFalse(condition.compare(null));
+        assertTrue( condition.compare(new Long(10)));
+        assertFalse(condition.compare(new Long(11)));
+
+        // Prohibited by Factory
+        // LongCondition condition = new LongCondition("==", null, false);
+    }
+
+    @Test
+    public void testNotEquals() {
+        LongCondition condition = new LongCondition("!=", new Long(10), false);
+        assertTrue( condition.compare(null));
+        assertFalse(condition.compare(new Long(10)));
+        assertTrue( condition.compare(new Long(11)));
+    }
+
+    @Test
+    public void testGreaterThan() {
+        LongCondition condition = new LongCondition(">", new Long(10), false);
+        assertFalse(condition.compare(null));
+        assertFalse(condition.compare(new Long(10)));
+        assertTrue( condition.compare(new Long(11)));
+    }
+
+    @Test
+    public void testGreaterEqual() {
+        LongCondition condition = new LongCondition(">=", new Long(11), false);
+        assertFalse(condition.compare(null));
+        assertFalse(condition.compare(new Long(10)));
+        assertTrue( condition.compare(new Long(11)));
+    }
+
+    @Test
+    public void testLessThan() {
+        LongCondition condition = new LongCondition("<", new Long(11), false);
+        assertFalse(condition.compare(null));
+        assertFalse(condition.compare(new Long(11)));
+        assertTrue( condition.compare(new Long(10)));
+    }
+
+    @Test
+    public void testLessEqual() {
+        LongCondition condition = new LongCondition("<=", new Long(11), false);
+        assertFalse(condition.compare(null));
+        assertFalse(condition.compare(new Long(12)));
+        assertTrue( condition.compare(new Long(11)));
+    }
+
+    @Test
+    public void testNot() {
+        LongCondition condition = new LongCondition("<=", new Long(11), true);
+        assertTrue( condition.compare(null));
+        assertTrue( condition.compare(new Long(12)));
+        assertFalse(condition.compare(new Long(11)));
+    }
+}

data/src/test/java/org/embulk/filter/row/TestStringCondition.java

@@ -0,0 +1,73 @@
+package org.embulk.filter.row;
+
+import org.embulk.filter.row.StringCondition;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class TestStringCondition
+{
+    @Test
+    public void testIsNull() {
+        StringCondition condition = new StringCondition("IS NULL", null, false);
+        assertTrue(condition.compare(null));
+        assertFalse(condition.compare("foo"));
+    }
+
+    @Test
+    public void testIsNotNull() {
+        StringCondition condition = new StringCondition("IS NOT NULL", null, false);
+        assertFalse(condition.compare(null));
+        assertTrue(condition.compare("foo"));
+    }
+
+    @Test
+    public void testEquals() {
+        StringCondition condition = new StringCondition("==", "foo", false);
+        assertFalse(condition.compare(null));
+        assertTrue( condition.compare("foo"));
+        assertFalse(condition.compare("bar"));
+
+        // Prohibited by Factory
+        // StringCondition condition = new StringCondition("==", null, false);
+    }
+
+    @Test
+    public void testNotEquals() {
+        StringCondition condition = new StringCondition("!=", "foo", false);
+        assertTrue( condition.compare(null));
+        assertFalse(condition.compare("foo"));
+        assertTrue( condition.compare("bar"));
+    }
+
+    @Test
+    public void testStartWith() {
+        StringCondition condition = new StringCondition("start_with", "f", false);
+        assertFalse(condition.compare(null));
+        assertTrue( condition.compare("foo"));
+        assertFalse(condition.compare("bar"));
+    }
+
+    @Test
+    public void testEndWith() {
+        StringCondition condition = new StringCondition("end_with", "o", false);
+        assertFalse(condition.compare(null));
+        assertTrue( condition.compare("foo"));
+        assertFalse(condition.compare("bar"));
+    }
+
+    @Test
+    public void testInclude() {
+        StringCondition condition = new StringCondition("include", "o", false);
+        assertFalse(condition.compare(null));
+        assertTrue( condition.compare("foo"));
+        assertFalse(condition.compare("bar"));
+    }
+
+    @Test
+    public void testNot() {
+        StringCondition condition = new StringCondition("include", "o", true);
+        assertTrue( condition.compare(null));
+        assertFalse(condition.compare("foo"));
+        assertTrue( condition.compare("bar"));
+    }
+}