embulk-filter-row 0.2.2 → 0.3.0

data/src/main/java/org/embulk/filter/row/where/_lexer.l

@@ -0,0 +1,108 @@
+package org.embulk.filter.row.where;
+
+import org.embulk.spi.Schema;
+%%
+
+%byaccj
+
+%{
+  private StringBuffer string = new StringBuffer();
+
+  protected Parser yyparser;
+  protected Schema schema;
+
+  public Yylex(String str, Parser yyparser) {
+    this(new java.io.StringReader(str));
+    this.yyparser = yyparser;
+    this.schema = yyparser.schema;
+  }
+%}
+
+%state STRING
+%state IDENTIFIER
+
+Number = -?[0-9]+(\.[0-9]+)?
+QuotedIdentifierChar = [^\r\n\"\\]
+NonQuotedIdentifier = [a-zA-Z$][a-zA-z0-9\.\-_]*
+StringChar = [^\r\n\'\\]+
+Newline = \n|\r|\r\n
+
+%%
+
+<YYINITIAL> {
+  /* operators */
+  "("                        { return (int) yycharat(0); }
+  ")"                        { return (int) yycharat(0); }
+  "AND"                      { return Parser.AND; }
+  "OR"                       { return Parser.OR; }
+  "="                        { return Parser.EQ; }
+  "<>" | "!="                { return Parser.NEQ; }
+  "!="                       { return Parser.NEQ; }
+  ">"                        { return Parser.GT; }
+  ">="                       { return Parser.GE; }
+  "<"                        { return Parser.LT; }
+  "<="                       { return Parser.LE; }
+  "START_WITH"               { return Parser.START_WITH; }
+  "END_WITH"                 { return Parser.END_WITH; }
+  "INCLUDE"                  { return Parser.INCLUDE; }
+  "IS"                       { return Parser.IS; }
+  "NOT"                      { return Parser.NOT; }
+  "NULL"                     { return Parser.NULL; }
+  "TIMESTAMP"                { return Parser.TIMESTAMP; }
+
+  /* boolean literal */
+  "true" | "TRUE"            { yyparser.yylval = new ParserVal(new BooleanLiteral(true)); return Parser.BOOLEAN; }
+  "false" | "FALSE"          { yyparser.yylval = new ParserVal(new BooleanLiteral(false)); return Parser.BOOLEAN; }
+
+  /* number literal */
+  {Number}                   { yyparser.yylval = new ParserVal(new NumberLiteral(yytext())); return Parser.NUMBER; }
+  
+  /* identifier literal */
+  {NonQuotedIdentifier}      { yyparser.yylval = new ParserVal(new IdentifierLiteral(yytext(), schema)); return Parser.IDENTIFIER; }
+  \"                         { yybegin(IDENTIFIER); string.setLength(0); }
+
+  /* string literal */
+  \'                         { yybegin(STRING); string.setLength(0); }
+
+  /* whitespace */
+  [ \t]+ { }
+
+  /* newline */
+  {Newline} { }
+}
+
+<IDENTIFIER> {
+  \"                         { yybegin(YYINITIAL); yyparser.yylval = new ParserVal(new IdentifierLiteral(string.toString(), schema)); return Parser.IDENTIFIER; }
+
+  {QuotedIdentifierChar}+    { string.append( yytext() ); }
+
+  /* escape sequences */
+  "\\\""                     { string.append( '\"' ); }
+  "\\'"                      { string.append( '\'' ); }
+  "\\\\"                     { string.append( '\\' ); }
+  
+  /* error cases */
+  \\.                        { throw new RuntimeException("yylex: Illegal escape sequence \""+yytext()+"\""); }
+}
+
+<STRING> {
+  \'                         { yybegin(YYINITIAL); yyparser.yylval = new ParserVal(new StringLiteral(string.toString())); return Parser.STRING; }
+  
+  {StringChar}+              { string.append( yytext() ); }
+  
+  /* escape sequences */
+  "\\b"                      { string.append( '\b' ); }
+  "\\t"                      { string.append( '\t' ); }
+  "\\n"                      { string.append( '\n' ); }
+  "\\f"                      { string.append( '\f' ); }
+  "\\r"                      { string.append( '\r' ); }
+  "\\\""                     { string.append( '\"' ); }
+  "\\'"                      { string.append( '\'' ); }
+  "\\\\"                     { string.append( '\\' ); }
+  
+  /* error cases */
+  \\.                        { throw new RuntimeException("yylex: Illegal escape sequence \""+yytext()+"\""); }
+}
+
+/* error fallback */
+[^]                          { throw new RuntimeException("yylex: Unexpected character '"+yytext()+"'"); }

data/src/main/java/org/embulk/filter/row/where/_parser.y

@@ -0,0 +1,137 @@
+%{
+import org.embulk.spi.Column;
+import org.embulk.spi.Schema;
+%}
+
+/* YACC Declarations */
+%token EQ  /* = */
+%token NEQ /* <> != */
+%token GT  /* >  */ 
+%token GE  /* >= */
+%token LT  /* <  */
+%token LE  /* <= */
+
+%token START_WITH
+%token END_WITH
+%token INCLUDE
+%token IS
+%token NOT
+
+%token AND
+%token OR
+
+%token NULL
+%token BOOLEAN
+%token STRING
+%token NUMBER
+%token IDENTIFIER
+
+%token TIMESTAMP
+
+%left OR
+%left AND
+%right TIMESTAMP
+%right NOT
+
+/* Grammar follows */
+%%
+input: /* empty string */
+ | exp { root = $1; }
+ ;
+
+timestamp: TIMESTAMP STRING     { $$ = new ParserVal(new TimestampLiteral($2)); }
+ | TIMESTAMP NUMBER             { $$ = new ParserVal(new TimestampLiteral($2)); }
+
+exp: IDENTIFIER EQ BOOLEAN      { $$ = new ParserVal(new BooleanOpExp($1, $3, EQ)); }
+ | IDENTIFIER NEQ BOOLEAN       { $$ = new ParserVal(new BooleanOpExp($1, $3, NEQ)); }
+ | BOOLEAN EQ  IDENTIFIER       { $$ = new ParserVal(new BooleanOpExp($1, $3, EQ)); }
+ | BOOLEAN NEQ IDENTIFIER       { $$ = new ParserVal(new BooleanOpExp($1, $3, NEQ)); }
+ | IDENTIFIER EQ  NUMBER        { $$ = new ParserVal(new NumberOpExp($1, $3, EQ)); }
+ | IDENTIFIER NEQ NUMBER        { $$ = new ParserVal(new NumberOpExp($1, $3, NEQ)); }
+ | IDENTIFIER GT  NUMBER        { $$ = new ParserVal(new NumberOpExp($1, $3, GT)); }
+ | IDENTIFIER GE  NUMBER        { $$ = new ParserVal(new NumberOpExp($1, $3, GE)); }
+ | IDENTIFIER LT  NUMBER        { $$ = new ParserVal(new NumberOpExp($1, $3, LT)); }
+ | IDENTIFIER LE  NUMBER        { $$ = new ParserVal(new NumberOpExp($1, $3, LE)); }
+ | NUMBER EQ  IDENTIFIER        { $$ = new ParserVal(new NumberOpExp($1, $3, EQ)); }
+ | NUMBER NEQ IDENTIFIER        { $$ = new ParserVal(new NumberOpExp($1, $3, NEQ)); }
+ | NUMBER GT  IDENTIFIER        { $$ = new ParserVal(new NumberOpExp($1, $3, GT)); }
+ | NUMBER GE  IDENTIFIER        { $$ = new ParserVal(new NumberOpExp($1, $3, GE)); }
+ | NUMBER LT  IDENTIFIER        { $$ = new ParserVal(new NumberOpExp($1, $3, LT)); }
+ | NUMBER LE  IDENTIFIER        { $$ = new ParserVal(new NumberOpExp($1, $3, LE)); }
+ | IDENTIFIER EQ         STRING { $$ = new ParserVal(new StringOpExp($1, $3, EQ)); }
+ | IDENTIFIER NEQ        STRING { $$ = new ParserVal(new StringOpExp($1, $3, NEQ)); }
+ | IDENTIFIER START_WITH STRING { $$ = new ParserVal(new StringOpExp($1, $3, START_WITH)); }
+ | IDENTIFIER END_WITH   STRING { $$ = new ParserVal(new StringOpExp($1, $3, END_WITH)); }
+ | IDENTIFIER INCLUDE    STRING { $$ = new ParserVal(new StringOpExp($1, $3, INCLUDE)); }
+ | STRING EQ         IDENTIFIER { $$ = new ParserVal(new StringOpExp($1, $3, EQ)); }
+ | STRING NEQ        IDENTIFIER { $$ = new ParserVal(new StringOpExp($1, $3, NEQ)); }
+ | STRING START_WITH IDENTIFIER { $$ = new ParserVal(new StringOpExp($1, $3, START_WITH)); }
+ | STRING END_WITH   IDENTIFIER { $$ = new ParserVal(new StringOpExp($1, $3, END_WITH)); }
+ | STRING INCLUDE    IDENTIFIER { $$ = new ParserVal(new StringOpExp($1, $3, INCLUDE)); }
+ | IDENTIFIER EQ  timestamp     { $$ = new ParserVal(new TimestampOpExp($1, $3, EQ)); }
+ | IDENTIFIER NEQ timestamp     { $$ = new ParserVal(new TimestampOpExp($1, $3, NEQ)); }
+ | IDENTIFIER GT  timestamp     { $$ = new ParserVal(new TimestampOpExp($1, $3, GT)); }
+ | IDENTIFIER GE  timestamp     { $$ = new ParserVal(new TimestampOpExp($1, $3, GE)); }
+ | IDENTIFIER LT  timestamp     { $$ = new ParserVal(new TimestampOpExp($1, $3, LT)); }
+ | IDENTIFIER LE  timestamp     { $$ = new ParserVal(new TimestampOpExp($1, $3, LE)); }
+ | timestamp EQ  IDENTIFIER     { $$ = new ParserVal(new TimestampOpExp($1, $3, EQ)); }
+ | timestamp NEQ IDENTIFIER     { $$ = new ParserVal(new TimestampOpExp($1, $3, NEQ)); }
+ | timestamp GT  IDENTIFIER     { $$ = new ParserVal(new TimestampOpExp($1, $3, GT)); }
+ | timestamp GE  IDENTIFIER     { $$ = new ParserVal(new TimestampOpExp($1, $3, GE)); }
+ | timestamp LT  IDENTIFIER     { $$ = new ParserVal(new TimestampOpExp($1, $3, LT)); }
+ | timestamp LE  IDENTIFIER     { $$ = new ParserVal(new TimestampOpExp($1, $3, LE)); }
+ | IDENTIFIER IS NULL           { $$ = new ParserVal(new NullOpExp($1, EQ)); }
+ | IDENTIFIER IS NOT NULL       { $$ = new ParserVal(new NullOpExp($1, NEQ)); }
+ | exp OR exp                   { $$ = new ParserVal(new LogicalOpExp($1, $3, OR)); }
+ | exp AND exp                  { $$ = new ParserVal(new LogicalOpExp($1, $3, AND)); }
+ | NOT exp                      { $$ = new ParserVal(new NegateOpExp($2)); }
+ | '(' exp ')'                  { $$ = $2; }
+ ;
+%%
+
+protected Schema schema;
+protected Yylex lexer;
+protected ParserVal root;
+
+public Parser(final Schema schema)
+{
+    this.schema = schema;
+}
+
+public Parser(final Schema schema, boolean yydebug)
+{
+    this.schema = schema;
+    this.yydebug = yydebug;
+}
+
+public ParserExp parse(String str)
+{
+    lexer = new Yylex(str, this);
+    yyparse();
+    return ((ParserExp)(root.obj));
+}
+
+private int yylex () {
+    int token = -1;
+    try {
+        token = lexer.yylex(); // next token
+    }
+    catch (java.io.IOException e) {
+        e.printStackTrace(); // should not happen
+    }
+    return token;
+}
+
+void yyerror(String s)
+{
+    throw new RuntimeException("yyerror: " + s);
+}
+
+/*public static void main(String args[])
+{
+    Parser yyparser = new Parser();
+    ParserExp exp = yyparser.parse("boolean = true");
+    HashMap<String, Object> variables = new HashMap<>();
+    variables.put("boolean", Boolean.TRUE);
+    System.out.println("ans: " + exp.eval(variables));
+}*/

data/src/test/java/org/embulk/filter/row/where/TestParser.java

@@ -0,0 +1,383 @@
+package org.embulk.filter.row.where;
+
+import org.embulk.EmbulkTestRuntime;
+import org.embulk.config.ConfigException;
+import org.embulk.spi.Page;
+import org.embulk.spi.PageReader;
+import org.embulk.spi.PageTestUtils;
+import org.embulk.spi.Schema;
+import org.embulk.spi.SchemaConfigException;
+import org.embulk.spi.time.Timestamp;
+
+import org.embulk.spi.time.TimestampParseException;
+import org.jruby.embed.ScriptingContainer;
+import org.junit.BeforeClass;
+import org.junit.Rule;
+import org.junit.Test;
+import org.msgpack.value.Value;
+import org.msgpack.value.ValueFactory;
+
+import java.util.List;
+
+import static org.embulk.spi.type.Types.BOOLEAN;
+import static org.embulk.spi.type.Types.DOUBLE;
+import static org.embulk.spi.type.Types.JSON;
+import static org.embulk.spi.type.Types.LONG;
+import static org.embulk.spi.type.Types.STRING;
+import static org.embulk.spi.type.Types.TIMESTAMP;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class TestParser
+{
+    private static EmbulkTestRuntime runtime = new EmbulkTestRuntime(); // very slow
+    private static ScriptingContainer jruby = new ScriptingContainer();
+
+    private static PageReader buildPageReader(Schema schema, final Object... objects)
+    {
+        PageReader pageReader = new PageReader(schema);
+        List<Page> pages = PageTestUtils.buildPage(runtime.getBufferAllocator(), schema, objects);
+        for (Page page : pages) {
+            pageReader.setPage(page);
+        }
+        pageReader.nextRecord();
+        return pageReader;
+    }
+
+    private static PageReader reader;
+    private static Schema schema;
+
+    @BeforeClass
+    public static void setupBeforeClass()
+    {
+        ParserLiteral.setJRuby(jruby);
+
+        // {"k1":{"k1":"v"},"k2":{"k2":"v"}}
+        Value k1 = ValueFactory.newString("k1");
+        Value k2 = ValueFactory.newString("k2");
+        Value v = ValueFactory.newString("v");
+        Value map = ValueFactory.newMap(
+                k1, ValueFactory.newMap(k1, v),
+                k2, ValueFactory.newMap(k2, v));
+
+        schema = Schema.builder()
+                .add("timestamp", TIMESTAMP)
+                .add("string", STRING)
+                .add("boolean", BOOLEAN)
+                .add("long", LONG)
+                .add("double", DOUBLE)
+                .add("true", BOOLEAN)
+                .add("null", BOOLEAN)
+                .add("json", JSON)
+                .build();
+
+        reader = buildPageReader(schema,
+                Timestamp.ofEpochSecond(1, 500000000),
+                "string",
+                true,
+                1L,
+                1.5,
+                true,
+                null,
+                map
+                );
+    }
+
+    @Test
+    public void testIdentifierLiteral()
+    {
+        Parser parser = new Parser(schema);
+        ParserExp exp;
+
+        exp = parser.parse("boolean = true");
+        assertTrue(exp.eval(reader));
+
+        exp = parser.parse("\"true\" = true");
+        assertTrue(exp.eval(reader));
+
+        try {
+            exp = parser.parse("\"unknown\" IS NULL");
+            assertTrue(false);
+        }
+        catch (SchemaConfigException e) {
+        }
+    }
+
+    @Test
+    public void testBooleanOpExp()
+    {
+        Parser parser = new Parser(schema);
+        ParserExp exp;
+
+        exp = parser.parse("boolean = true");
+        assertTrue(exp.eval(reader));
+        exp = parser.parse("boolean = false");
+        assertFalse(exp.eval(reader));
+
+        exp = parser.parse("boolean != false");
+        assertTrue(exp.eval(reader));
+        exp = parser.parse("boolean != true");
+        assertFalse(exp.eval(reader));
+
+        exp = parser.parse("true = boolean");
+        assertTrue(exp.eval(reader));
+
+        try {
+            exp = parser.parse("timestamp = true");
+            assertTrue(false);
+        }
+        catch (ConfigException e) {
+        }
+    }
+
+    @Test
+    public void testNumberOpExp()
+    {
+        Parser parser = new Parser(schema);
+        ParserExp exp;
+
+        exp = parser.parse("double = 1.5");
+        assertTrue(exp.eval(reader));
+        exp = parser.parse("double = 1.0");
+        assertFalse(exp.eval(reader));
+
+        exp = parser.parse("double != 1.0");
+        assertTrue(exp.eval(reader));
+        exp = parser.parse("double != 1.5");
+        assertFalse(exp.eval(reader));
+
+        exp = parser.parse("double > 1.0");
+        assertTrue(exp.eval(reader));
+        exp = parser.parse("double > 1.5");
+        assertFalse(exp.eval(reader));
+
+        exp = parser.parse("double >= 1.5");
+        assertTrue(exp.eval(reader));
+        exp = parser.parse("double >= 2.0");
+        assertFalse(exp.eval(reader));
+
+        exp = parser.parse("double < 2.0");
+        assertTrue(exp.eval(reader));
+        exp = parser.parse("double < 1.5");
+        assertFalse(exp.eval(reader));
+
+        exp = parser.parse("double <= 1.5");
+        assertTrue(exp.eval(reader));
+        exp = parser.parse("double <= 1.0");
+        assertFalse(exp.eval(reader));
+
+        exp = parser.parse("1.5 = double");
+        assertTrue(exp.eval(reader));
+
+        try {
+            exp = parser.parse("timestamp = 1.5");
+            assertTrue(false);
+        }
+        catch (ConfigException e) {
+        }
+    }
+
+    @Test
+    public void testStringOpExp()
+    {
+        Parser parser = new Parser(schema);
+        ParserExp exp;
+
+        exp = parser.parse("string = 'string'");
+        assertTrue(exp.eval(reader));
+        exp = parser.parse("string = 'foobar'");
+        assertFalse(exp.eval(reader));
+
+        exp = parser.parse("string != 'foobar'");
+        assertTrue(exp.eval(reader));
+        exp = parser.parse("string != 'string'");
+        assertFalse(exp.eval(reader));
+
+        exp = parser.parse("string <> 'foobar'");
+        assertTrue(exp.eval(reader));
+        exp = parser.parse("string <> 'string'");
+        assertFalse(exp.eval(reader));
+
+        exp = parser.parse("string START_WITH 's'");
+        assertTrue(exp.eval(reader));
+        exp = parser.parse("string START_WITH 'f'");
+        assertFalse(exp.eval(reader));
+
+        exp = parser.parse("string END_WITH 'g'");
+        assertTrue(exp.eval(reader));
+        exp = parser.parse("string END_WITH 'r'");
+        assertFalse(exp.eval(reader));
+
+        exp = parser.parse("string INCLUDE 'tr'");
+        assertTrue(exp.eval(reader));
+        exp = parser.parse("string INCLUDE 'oo'");
+        assertFalse(exp.eval(reader));
+
+        exp = parser.parse("'string' = string");
+        assertTrue(exp.eval(reader));
+
+        try {
+            exp = parser.parse("timestamp = 'string'");
+            assertTrue(false);
+        }
+        catch (ConfigException e) {
+        }
+    }
+
+    @Test
+    public void testTimestampOpExpWithNumber()
+    {
+        Parser parser = new Parser(schema);
+        ParserExp exp;
+
+        exp = parser.parse("timestamp = TIMESTAMP 1.5");
+        assertTrue(exp.eval(reader));
+        exp = parser.parse("timestamp = TIMESTAMP 1.0");
+        assertFalse(exp.eval(reader));
+
+        exp = parser.parse("timestamp != TIMESTAMP 1.0");
+        assertTrue(exp.eval(reader));
+        exp = parser.parse("timestamp != TIMESTAMP 1.5");
+        assertFalse(exp.eval(reader));
+
+        exp = parser.parse("timestamp > TIMESTAMP 1.0");
+        assertTrue(exp.eval(reader));
+        exp = parser.parse("timestamp > TIMESTAMP 1.5");
+        assertFalse(exp.eval(reader));
+
+        exp = parser.parse("timestamp >= TIMESTAMP 1.5");
+        assertTrue(exp.eval(reader));
+        exp = parser.parse("timestamp >= TIMESTAMP 2.0");
+        assertFalse(exp.eval(reader));
+
+        exp = parser.parse("timestamp < TIMESTAMP 2.0");
+        assertTrue(exp.eval(reader));
+        exp = parser.parse("timestamp < TIMESTAMP 1.5");
+        assertFalse(exp.eval(reader));
+
+        exp = parser.parse("timestamp <= TIMESTAMP 1.5");
+        assertTrue(exp.eval(reader));
+        exp = parser.parse("timestamp <= TIMESTAMP 1.0");
+        assertFalse(exp.eval(reader));
+
+        exp = parser.parse("TIMESTAMP 1.5 = timestamp");
+        assertTrue(exp.eval(reader));
+    }
+
+    @Test
+    public void testTimestampOpExpWithString()
+    {
+        Parser parser = new Parser(schema);
+        ParserExp exp;
+
+        exp = parser.parse("timestamp = TIMESTAMP '1970-01-01 09:00:01.5 +0900'");
+        assertTrue(exp.eval(reader));
+        exp = parser.parse("timestamp = TIMESTAMP '1970-01-01 09:00:01.0 +09:00'");
+        assertFalse(exp.eval(reader));
+
+        exp = parser.parse("timestamp != TIMESTAMP '1970-01-01 09:00:01.0 +0900'");
+        assertTrue(exp.eval(reader));
+        exp = parser.parse("timestamp != TIMESTAMP '1970-01-01 09:00:01.5 +0900'");
+        assertFalse(exp.eval(reader));
+
+        exp = parser.parse("timestamp >  TIMESTAMP '1970-01-01 09:00:01.0 +0900'");
+        assertTrue(exp.eval(reader));
+        exp = parser.parse("timestamp >  TIMESTAMP '1970-01-01 09:00:01.5 +0900'");
+        assertFalse(exp.eval(reader));
+
+        exp = parser.parse("timestamp >= TIMESTAMP '1970-01-01 09:00:01.5 +09:00'");
+        assertTrue(exp.eval(reader));
+        exp = parser.parse("timestamp >= TIMESTAMP '1970-01-01 09:00:02.0 +09:00'");
+        assertFalse(exp.eval(reader));
+
+        exp = parser.parse("timestamp <  TIMESTAMP '1970-01-01 09:00:02.0 +09:00'");
+        assertTrue(exp.eval(reader));
+        exp = parser.parse("timestamp <  TIMESTAMP '1970-01-01 09:00:01.5 +09:00'");
+        assertFalse(exp.eval(reader));
+
+        exp = parser.parse("timestamp <= TIMESTAMP '1970-01-01 09:00:01.5 +09:00'");
+        assertTrue(exp.eval(reader));
+        exp = parser.parse("timestamp <= TIMESTAMP '1970-01-01 09:00:01.0 +09:00'");
+        assertFalse(exp.eval(reader));
+
+        exp = parser.parse("TIMESTAMP '1970-01-01 09:00:01.5 +09:00' = timestamp");
+        assertTrue(exp.eval(reader));
+
+        exp = parser.parse("timestamp = TIMESTAMP '1970-01-01 09:00:01.5 +0900'");
+        assertTrue(exp.eval(reader));
+        exp = parser.parse("timestamp = TIMESTAMP '1970-01-01 00:00:01.5'");
+        assertTrue(exp.eval(reader));
+        exp = parser.parse("timestamp = TIMESTAMP '1970-01-01 09:00:01 +09:00'");
+        assertFalse(exp.eval(reader));
+        exp = parser.parse("timestamp = TIMESTAMP '1970-01-01 00:00:01'");
+        assertFalse(exp.eval(reader));
+        exp = parser.parse("timestamp = TIMESTAMP '1970-01-01 +09:00'");
+        assertFalse(exp.eval(reader));
+        exp = parser.parse("timestamp = TIMESTAMP '1970-01-01'");
+        assertFalse(exp.eval(reader));
+
+        try {
+            parser.parse("timestamp = TIMESTAMP '1970:01:01'");
+            assertTrue(false);
+        }
+        catch (TimestampParseException ex) {
+        }
+    }
+
+    @Test
+    public void testNullOpExp()
+    {
+        Parser parser = new Parser(schema);
+        ParserExp exp;
+
+        exp = parser.parse("null IS NULL");
+        assertTrue(exp.eval(reader));
+        exp = parser.parse("null IS NOT NULL");
+        assertFalse(exp.eval(reader));
+
+        exp = parser.parse("string IS NOT NULL");
+        assertTrue(exp.eval(reader));
+        exp = parser.parse("string IS NULL");
+        assertFalse(exp.eval(reader));
+    }
+
+    @Test
+    public void testLogicalOpExp()
+    {
+        Parser parser = new Parser(schema);
+        ParserExp exp;
+
+        exp = parser.parse("\"true\" = true AND \"true\" = true");
+        assertTrue(exp.eval(reader));
+        exp = parser.parse("\"true\" = true AND \"true\" = false");
+        assertFalse(exp.eval(reader));
+
+        exp = parser.parse("\"true\" = false OR \"true\" = true");
+        assertTrue(exp.eval(reader));
+        exp = parser.parse("\"true\" = false OR \"true\" = false");
+        assertFalse(exp.eval(reader));
+
+        // a AND b OR c #=> (a AND b) OR c
+        // a OR b AND c #=> a OR (b AND c)
+        exp = parser.parse("\"true\" = true OR \"true\" = false AND \"true\" = false");
+        assertTrue(exp.eval(reader));
+        exp = parser.parse("( \"true\" = true OR \"true\" = false ) AND \"true\" = false");
+        assertFalse(exp.eval(reader));
+    }
+
+    @Test
+    public void testNegateOpExp()
+    {
+        Parser parser = new Parser(schema);
+        ParserExp exp;
+
+        exp = parser.parse("NOT \"true\" = false");
+        assertTrue(exp.eval(reader));
+        exp = parser.parse("NOT ( \"true\" = false )");
+        assertTrue(exp.eval(reader));
+
+        // NOT a AND B #=> (NOT a) AND B
+        exp = parser.parse("NOT \"true\" = false AND \"true\" = true");
+        assertTrue(exp.eval(reader));
+    }
+}