embulk-filter-row 0.2.2 → 0.3.0

data/src/main/java/org/embulk/filter/row/where/ParserExp.java

@@ -0,0 +1,290 @@
+package org.embulk.filter.row.where;
+
+import org.embulk.config.ConfigException;
+import org.embulk.spi.PageReader;
+import org.embulk.spi.time.Timestamp;
+
+// Operation Node of AST (Abstract Syntax Tree)
+public abstract class ParserExp extends ParserNode
+{
+    public abstract boolean eval(PageReader pageReader);
+}
+
+abstract class BinaryOpExp extends ParserExp
+{
+    protected ParserLiteral left;
+    protected ParserLiteral right;
+    protected int operator;
+
+    public BinaryOpExp(ParserLiteral left, ParserLiteral right, int operator)
+    {
+        this.left = left;
+        this.right = right;
+        this.operator = operator;
+    }
+
+    public BinaryOpExp(ParserVal left, ParserVal right, int operator)
+    {
+        this((ParserLiteral)(left.obj), (ParserLiteral)(right.obj), operator);
+    }
+}
+
+class BooleanOpExp extends BinaryOpExp
+{
+    public BooleanOpExp(ParserLiteral left, ParserLiteral right, int operator)
+    {
+        super(left, right, operator);
+        if (! left.isBoolean()) {
+            throw new ConfigException(String.format("\"%s\" is not a Boolean column", ((IdentifierLiteral)left).name));
+        }
+        if (! right.isBoolean()) {
+            throw new ConfigException(String.format("\"%s\" is not a Boolean column", ((IdentifierLiteral)right).name));
+        }
+    }
+
+    public BooleanOpExp(ParserVal left, ParserVal right, int operator)
+    {
+        this((ParserLiteral)(left.obj), (ParserLiteral)(right.obj), operator);
+    }
+
+    public boolean eval(PageReader pageReader)
+    {
+        boolean l = left.getBoolean(pageReader);
+        boolean r = right.getBoolean(pageReader);
+        if (operator == Parser.EQ) {
+            return l == r;
+        }
+        else if (operator == Parser.NEQ) {
+            return l != r;
+        }
+        else {
+            assert(false);
+            return false;
+        }
+    }
+}
+
+class NumberOpExp extends BinaryOpExp
+{
+    public NumberOpExp(ParserLiteral left, ParserLiteral right, int operator)
+    {
+        super(left, right, operator);
+        if (! left.isNumber()) {
+            throw new ConfigException(String.format("\"%s\" is not a Number column", ((IdentifierLiteral)left).name));
+        }
+        if (! right.isNumber()) {
+            throw new ConfigException(String.format("\"%s\" is not a Number column", ((IdentifierLiteral)right).name));
+        }
+    }
+
+    public NumberOpExp(ParserVal left, ParserVal right, int operator)
+    {
+        this((ParserLiteral)(left.obj), (ParserLiteral)(right.obj), operator);
+    }
+
+    public boolean eval(PageReader pageReader)
+    {
+        double l = left.getNumber(pageReader);
+        double r = right.getNumber(pageReader);
+        if (operator == Parser.EQ) {
+            return l == r;
+        }
+        else if (operator == Parser.NEQ) {
+            return l != r;
+        }
+        else if (operator == Parser.GT) {
+            return l > r;
+        }
+        else if (operator == Parser.GE) {
+            return l >= r;
+        }
+        else if (operator == Parser.LT) {
+            return l < r;
+        }
+        else if (operator == Parser.LE) {
+            return l <= r;
+        }
+        else {
+            assert(false);
+            return false;
+        }
+    }
+}
+
+class TimestampOpExp extends BinaryOpExp
+{
+    public TimestampOpExp(ParserLiteral left, ParserLiteral right, int operator)
+    {
+        super(left, right, operator);
+        if (! left.isTimestamp()) {
+            throw new ConfigException(String.format("\"%s\" is not a Timestamp column", ((IdentifierLiteral)left).name));
+        }
+        if (! right.isTimestamp()) {
+            throw new ConfigException(String.format("\"%s\" is not a Timestamp column", ((IdentifierLiteral)right).name));
+        }
+    }
+
+    public TimestampOpExp(ParserVal left, ParserVal right, int operator)
+    {
+        this((ParserLiteral)(left.obj), (ParserLiteral)(right.obj), operator);
+    }
+
+    public boolean eval(PageReader pageReader)
+    {
+        Timestamp l = left.getTimestamp(pageReader);
+        Timestamp r = right.getTimestamp(pageReader);
+        if (operator == Parser.EQ) {
+            return l.equals(r);
+        }
+        else if (operator == Parser.NEQ) {
+            return ! l.equals(r);
+        }
+        else if (operator == Parser.GT) {
+            return l.compareTo(r) > 0;
+        }
+        else if (operator == Parser.GE) {
+            return l.compareTo(r) >= 0;
+        }
+        else if (operator == Parser.LT) {
+            return l.compareTo(r) < 0;
+        }
+        else if (operator == Parser.LE) {
+            return l.compareTo(r) <= 0;
+        }
+        else {
+            assert(false);
+            return false;
+        }
+    }
+}
+
+class StringOpExp extends BinaryOpExp
+{
+    public StringOpExp(ParserLiteral left, ParserLiteral right, int operator)
+    {
+        super(left, right, operator);
+        if (! left.isString()) {
+            throw new ConfigException(String.format("\"%s\" is not a String column", ((IdentifierLiteral)left).name));
+        }
+        if (! right.isString()) {
+            throw new ConfigException(String.format("\"%s\" is not a String column", ((IdentifierLiteral)right).name));
+        }
+    }
+
+    public StringOpExp(ParserVal left, ParserVal right, int operator)
+    {
+        this((ParserLiteral)(left.obj), (ParserLiteral)(right.obj), operator);
+    }
+
+    public boolean eval(PageReader pageReader)
+    {
+        String l = left.getString(pageReader);
+        String r = right.getString(pageReader);
+        if (operator == Parser.EQ) {
+            return l.equals(r);
+        }
+        else if (operator == Parser.NEQ) {
+            return ! l.equals(r);
+        }
+        else if (operator == Parser.START_WITH) {
+            return l.startsWith(r);
+        }
+        else if (operator == Parser.END_WITH) {
+            return l.endsWith(r);
+        }
+        else if (operator == Parser.INCLUDE) {
+            return l.contains(r);
+        }
+        else {
+            assert(false);
+            return false;
+        }
+    }
+}
+
+class NullOpExp extends ParserExp
+{
+    protected ParserLiteral val;
+    protected int operator;
+
+    public NullOpExp(ParserLiteral val, int operator)
+    {
+        this.val = val;
+        this.operator = operator;
+    }
+
+    public NullOpExp(ParserVal val, int operator)
+    {
+        this((ParserLiteral)(val.obj), operator);
+    }
+
+    public boolean eval(PageReader pageReader)
+    {
+        boolean isNull = val.isNull(pageReader);
+        if (operator == Parser.EQ) {
+            return isNull;
+        }
+        else if (operator == Parser.NEQ) {
+            return ! isNull;
+        }
+        else {
+            assert(false);
+            return false;
+        }
+    }
+}
+
+class LogicalOpExp extends ParserExp
+{
+    protected ParserExp left;
+    protected ParserExp right;
+    protected int operator;
+
+    public LogicalOpExp(ParserExp left, ParserExp right, int operator)
+    {
+        this.left = left;
+        this.right = right;
+        this.operator = operator;
+    }
+
+    public LogicalOpExp(ParserVal left, ParserVal right, int operator)
+    {
+        this((ParserExp)(left.obj), (ParserExp)(right.obj), operator);
+    }
+
+    public boolean eval(PageReader pageReader)
+    {
+        boolean l = left.eval(pageReader);
+        boolean r = right.eval(pageReader);
+        if (operator == Parser.OR) {
+            return l || r;
+        }
+        else if (operator == Parser.AND) {
+            return l && r;
+        }
+        else {
+            assert(false);
+            return false;
+        }
+    }
+}
+
+class NegateOpExp extends ParserExp
+{
+    protected ParserExp exp;
+
+    public NegateOpExp(ParserExp exp)
+    {
+        this.exp = exp;
+    }
+
+    public NegateOpExp(ParserVal exp)
+    {
+        this((ParserExp)(exp.obj));
+    }
+
+    public boolean eval(PageReader pageReader)
+    {
+        return ! exp.eval(pageReader);
+    }
+}

data/src/main/java/org/embulk/filter/row/where/ParserLiteral.java

@@ -0,0 +1,277 @@
+package org.embulk.filter.row.where;
+
+import com.google.common.base.Throwables;
+import org.embulk.config.ConfigException;
+import org.embulk.spi.Column;
+import org.embulk.spi.PageReader;
+import org.embulk.spi.Schema;
+import org.embulk.spi.time.Timestamp;
+import org.embulk.spi.time.TimestampParseException;
+import org.embulk.spi.time.TimestampParser;
+import org.embulk.spi.type.BooleanType;
+import org.embulk.spi.type.DoubleType;
+import org.embulk.spi.type.JsonType;
+import org.embulk.spi.type.LongType;
+import org.embulk.spi.type.StringType;
+import org.embulk.spi.type.TimestampType;
+import org.embulk.spi.type.Type;
+import org.joda.time.DateTimeZone;
+import org.jruby.embed.ScriptingContainer;
+import org.msgpack.value.Value;
+
+// Literal Node of AST (Abstract Syntax Tree)
+public abstract class ParserLiteral extends ParserNode
+{
+    static ScriptingContainer jruby;
+
+    public static void setJRuby(ScriptingContainer jruby)
+    {
+        ParserLiteral.jruby = jruby;
+    }
+
+    public boolean isBoolean()
+    {
+        return false;
+    }
+    public boolean isNumber()
+    {
+        return false;
+    }
+    public boolean isString()
+    {
+        return false;
+    }
+    public boolean isTimestamp()
+    {
+        return false;
+    }
+    public boolean isJson()
+    {
+        return false;
+    }
+
+    public boolean isNull(PageReader pageReader)
+    {
+        throw new RuntimeException();
+    }
+    public boolean getBoolean(PageReader pageReader)
+    {
+        throw new RuntimeException();
+    }
+    public double getNumber(PageReader pageReader)
+    {
+        throw new RuntimeException();
+    }
+    public String getString(PageReader pageReader)
+    {
+        throw new RuntimeException();
+    }
+    public Timestamp getTimestamp(PageReader pageReader)
+    {
+        throw new RuntimeException();
+    }
+    public Value getJson(PageReader pageReader)
+    {
+        throw new RuntimeException();
+    }
+}
+
+class BooleanLiteral extends ParserLiteral
+{
+    public boolean val;
+
+    public BooleanLiteral(boolean val)
+    {
+        this.val = val;
+    }
+
+    public boolean isBoolean()
+    {
+        return true;
+    }
+
+    public boolean getBoolean(PageReader pageReader)
+    {
+        return val;
+    }
+}
+
+class NumberLiteral extends ParserLiteral
+{
+    protected double val;
+
+    public NumberLiteral(double val)
+    {
+        this.val = val;
+    }
+
+    public NumberLiteral(String str)
+    {
+        this.val = Double.parseDouble(str);
+    }
+
+    public boolean isNumber()
+    {
+        return true;
+    }
+
+    public double getNumber(PageReader pageReader)
+    {
+        return val;
+    }
+}
+
+class StringLiteral extends ParserLiteral
+{
+    protected String val;
+
+    public StringLiteral(String val)
+    {
+        this.val = val;
+    }
+
+    public boolean isString()
+    {
+        return true;
+    }
+
+    public String getString(PageReader pageReader)
+    {
+        return val;
+    }
+}
+
+class TimestampLiteral extends ParserLiteral
+{
+    protected Timestamp val;
+    private static final DateTimeZone default_timezone  = DateTimeZone.forID("UTC");
+
+    public TimestampLiteral(ParserVal val)
+    {
+        if (val.obj.getClass() == StringLiteral.class) {
+            initTimestampLiteral(((StringLiteral)val.obj).val);
+        }
+        else if (val.obj.getClass() == NumberLiteral.class) {
+            initTimestampLiteral(((NumberLiteral)(val.obj)).val);
+        }
+        else {
+            throw new RuntimeException();
+        }
+    }
+
+    public void initTimestampLiteral(String str)
+    {
+        String[] formats = {
+                "%Y-%m-%d %H:%M:%S.%N %z",
+                "%Y-%m-%d %H:%M:%S.%N",
+                "%Y-%m-%d %H:%M:%S %z",
+                "%Y-%m-%d %H:%M:%S",
+                "%Y-%m-%d %z",
+                "%Y-%m-%d",
+                };
+        Timestamp val = null;
+        TimestampParseException ex = null;
+        for (String format : formats) {
+            try {
+                TimestampParser timestampParser = new TimestampParser(jruby, format, default_timezone);
+                this.val = timestampParser.parse(str);
+                break;
+            }
+            catch (TimestampParseException e) {
+                ex = e;
+            }
+        }
+        if (this.val == null) {
+            throw Throwables.propagate(ex);
+        }
+    }
+
+    public void initTimestampLiteral(double epoch)
+    {
+        int epochSecond = (int) epoch;
+        long nanoAdjustment = (long) ((epoch - epochSecond) * 1000000000);
+        this.val = Timestamp.ofEpochSecond(epochSecond, nanoAdjustment);
+    }
+
+    public boolean isTimestamp()
+    {
+        return true;
+    }
+
+    public Timestamp getTimestamp(PageReader pageReader)
+    {
+        return val;
+    }
+}
+
+class IdentifierLiteral extends ParserLiteral
+{
+    protected String name;
+    protected Column column;
+
+    public IdentifierLiteral(String name, Schema schema)
+    {
+        this.name = name;
+        this.column = schema.lookupColumn(name); // throw SchemaConfigException
+        // ToDo: Support filtering value with type: json
+        if (column.getType() instanceof JsonType) {
+            throw new ConfigException(String.format("Identifier for a json column '%s' is not supported", name));
+        }
+    }
+
+    public boolean isBoolean()
+    {
+        return (column.getType() instanceof BooleanType);
+    }
+    public boolean isNumber()
+    {
+        return (column.getType() instanceof LongType) || (column.getType() instanceof DoubleType);
+    }
+    public boolean isString()
+    {
+        return (column.getType() instanceof StringType);
+    }
+    public boolean isTimestamp()
+    {
+        return (column.getType() instanceof TimestampType);
+    }
+    public boolean isJson()
+    {
+        return (column.getType() instanceof JsonType);
+    }
+
+    public boolean isNull(PageReader pageReader)
+    {
+        return pageReader.isNull(column);
+    }
+
+    public boolean getBoolean(PageReader pageReader)
+    {
+        return pageReader.getBoolean(column);
+    }
+
+    public double getNumber(PageReader pageReader)
+    {
+        if (column.getType() instanceof LongType) {
+            return (double) pageReader.getLong(column);
+        }
+        else {
+            return pageReader.getDouble(column);
+        }
+    }
+
+    public String getString(PageReader pageReader)
+    {
+        return pageReader.getString(column);
+    }
+
+    public Timestamp getTimestamp(PageReader pageReader)
+    {
+        return pageReader.getTimestamp(column);
+    }
+
+    public Value getJson(PageReader pageReader)
+    {
+        return pageReader.getJson(column);
+    }
+}

data/src/main/java/org/embulk/filter/row/where/ParserNode.java

@@ -0,0 +1,6 @@
+package org.embulk.filter.row.where;
+
+// Node of AST (Abstract Syntax Tree)
+public abstract class ParserNode
+{
+}

data/src/main/java/org/embulk/filter/row/where/ParserVal.java

@@ -0,0 +1,78 @@
+//#############################################
+//## file: Parser.java
+//## Generated by Byacc/j
+//#############################################
+package org.embulk.filter.row.where;
+
+/**
+ * BYACC/J Semantic Value for parser: Parser
+ * This class provides some of the functionality
+ * of the yacc/C 'union' directive
+ */
+public class ParserVal
+{
+/**
+ * integer value of this 'union'
+ */
+public int ival;
+
+/**
+ * double value of this 'union'
+ */
+public double dval;
+
+/**
+ * string value of this 'union'
+ */
+public String sval;
+
+/**
+ * object value of this 'union'
+ */
+public Object obj;
+
+//#############################################
+//## C O N S T R U C T O R S
+//#############################################
+/**
+ * Initialize me without a value
+ */
+public ParserVal()
+{
+}
+/**
+ * Initialize me as an int
+ */
+public ParserVal(int val)
+{
+  ival=val;
+}
+
+/**
+ * Initialize me as a double
+ */
+public ParserVal(double val)
+{
+  dval=val;
+}
+
+/**
+ * Initialize me as a string
+ */
+public ParserVal(String val)
+{
+  sval=val;
+}
+
+/**
+ * Initialize me as an Object
+ */
+public ParserVal(Object val)
+{
+  obj=val;
+}
+}//end class
+
+//#############################################
+//## E N D    O F    F I L E
+//#############################################