norikra 0.1.7-java → 1.0.0-java

data/lib/norikra/logger_mizuno_patch.rb

@@ -1,5 +1,5 @@
 require 'java'
-require 'esper/lib/log4j-1.2.16.jar'
+require 'esper/lib/log4j-1.2.17.jar'
 require 'mizuno/logger'
 
 module Mizuno

data/lib/norikra/query.rb

@@ -1,8 +1,8 @@
 require 'java'
-require 'esper-4.9.0.jar'
-require 'esper/lib/commons-logging-1.1.1.jar'
-require 'esper/lib/antlr-runtime-3.2.jar'
-require 'esper/lib/cglib-nodep-2.2.jar'
+require 'esper-5.0.0.jar'
+require 'esper/lib/commons-logging-1.1.3.jar'
+require 'esper/lib/antlr-runtime-4.1.jar'
+require 'esper/lib/cglib-nodep-3.1.jar'
 
 require 'norikra/error'
 require 'norikra/query/ast'
@@ -16,7 +16,8 @@ module Norikra
       @name = param[:name]
       raise Norikra::ArgumentError, "Query name MUST NOT be blank" if @name.nil? || @name.empty?
       @group = param[:group] # default nil
-      @expression = param[:expression]
+      #TODO: ad-hoc query rewriting for https://jira.codehaus.org/browse/ESPER-788
+      @expression = param[:expression].gsub(/([ ,])(MIN|MAX)\(/){ $1 + $2.downcase + '(' }
       raise Norikra::ArgumentError, "Query expression MUST NOT be blank" if @expression.nil? || @expression.empty?
 
       @statement_name = nil
@@ -44,6 +45,10 @@ module Norikra
       end
     end
 
+    def self.loopback(group)
+      group && group =~ /^LOOPBACK\((.+)\)$/ && $1
+    end
+
     def dup
       self.class.new(:name => @name, :group => @group, :expression => @expression.dup)
     end
@@ -155,9 +160,9 @@ module Norikra
     end
 
     class ParseRuleSelectorImpl
-      include com.espertech.esper.epl.parse.ParseRuleSelector
+      include Java::ComEspertechEsperEplParse::ParseRuleSelector
       def invokeParseRule(parser)
-        parser.startEPLExpressionRule().getTree()
+        parser.startEPLExpressionRule()
       end
     end
 
@@ -166,10 +171,35 @@ module Norikra
       rule = ParseRuleSelectorImpl.new
       target = @expression.dup
       forerrmsg = @expression.dup
-      result = com.espertech.esper.epl.parse.ParseHelper.parse(target, forerrmsg, true, rule, false)
-
-      @ast = astnode(result.getTree)
+      result = Java::ComEspertechEsperEplParse::ParseHelper.parse(target, forerrmsg, true, rule, false)
+
+      # walk through AST and check syntax errors/semantic errors
+      ast = result.tree
+
+      services = Java::ComEspertechEsperClient::EPServiceProviderManager.getDefaultProvider.getServicesContext
+
+      walker = Java::ComEspertechEsperEplParse::EPLTreeWalkerListener.new(
+        result.getTokenStream,
+        services.getEngineImportService,
+        services.getVariableService,
+        services.getSchedulingService,
+        Java::ComEspertechEsperEplSpec::SelectClauseStreamSelectorEnum.mapFromSODA(
+          services.getConfigSnapshot.getEngineDefaults.getStreamSelection.getDefaultStreamSelector
+        ),
+        services.getEngineURI,
+        services.getConfigSnapshot,
+        services.getPatternNodeFactory,
+        services.getContextManagementService,
+        result.getScripts,
+        services.getExprDeclaredService
+      )
+
+      Java::ComEspertechEsperEplParse::ParseHelper.walk(ast, walker, target, forerrmsg)
+
+      @ast = astnode(ast)
       @ast
+    rescue Java::ComEspertechEsperEplParse::ASTWalkException => e
+      raise Norikra::QueryError, e.message
     rescue Java::ComEspertechEsperClient::EPStatementSyntaxException => e
       raise Norikra::QueryError, e.message
     end
@@ -284,7 +314,10 @@ module Norikra
     end
 
     ### Targets and fields re-writing supports (*) nodes
-    # model.methods.select{|m| m.to_s.start_with?('get')}
+    # model.methods.select{|m| m.to_s.start_with?('get') && !m.to_s.start_with?('get_')}.sort
+
+    # :getAnnotations,
+    # :getClass,
     # :getContextName,
     # :getCreateContext,
     # :getCreateDataFlow,
@@ -338,6 +371,14 @@ module Norikra
             dig.call(c)
           end
         end
+        if node.respond_to?(:getExpression)
+          dig.call(node.getExpression)
+        end
+        if node.respond_to?(:getExpressions)
+          node.getExpressions.each do |e|
+            dig.call(e)
+          end
+        end
       }
 
       statement_model.getFromClause.getStreams.each do |stream|
@@ -361,9 +402,7 @@ module Norikra
 
       if statement_model.getSelectClause
         statement_model.getSelectClause.getSelectList.each do |item|
-          if item.respond_to?(:getExpression)
-            dig.call(item.getExpression)
-          end
+          dig.call(item)
         end
       end
 
@@ -374,16 +413,14 @@ module Norikra
       end
 
       if statement_model.getGroupByClause
-        statement_model.getGroupByClause.getGroupByExpressions.each do |child|
-          dig.call(child)
+        statement_model.getGroupByClause.getGroupByExpressions.each do |item|
+          dig.call(item)
         end
       end
 
       if statement_model.getOrderByClause
         statement_model.getOrderByClause.getOrderByExpressions.each do |item|
-          if item.respond_to?(:getExpression)
-            dig.call(item.getExpression)
-          end
+          dig.call(item)
         end
       end
 

data/lib/norikra/query/ast.rb

@@ -1,152 +1,762 @@
 module Norikra
   class Query
-    ### SELECT MAX(size) AS maxsize, fraud.aaa,bbb
+    ### SELECT max(size) AS maxsize, fraud.aaa, bbb
     ### FROM FraudWarningEvent.win:keepall() AS fraud,
     ###      PINChangeEvent(size > 10).win:time(20 sec)
     ### WHERE fraud.accountNumber.substr(0,8) = substr(PINChangeEvent.accountNumber, 0, 8)
     ###   AND cast(PINChangeEvent.size,double) > 10.5
-    #
-    # ["EPL_EXPR",
-    #  ["SELECTION_EXPR",
-    #   ["SELECTION_ELEMENT_EXPR",
-    #    ["LIB_FUNC_CHAIN",
-    #     ["LIB_FUNCTION",
-    #      "max",
-    #      ["EVENT_PROP_EXPR", ["EVENT_PROP_SIMPLE", "size"]],
-    #      "("]],
-    #    "maxsize"],
-    #   ["SELECTION_ELEMENT_EXPR",
-    #    ["EVENT_PROP_EXPR",
-    #     ["EVENT_PROP_SIMPLE", "fraud"],
-    #     ["EVENT_PROP_SIMPLE", "aaa"]]],
-    #   ["SELECTION_ELEMENT_EXPR",
-    #    ["EVENT_PROP_EXPR", ["EVENT_PROP_SIMPLE", "bbb"]]]],
-    #  ["STREAM_EXPR",
-    #   ["EVENT_FILTER_EXPR", "FraudWarningEvent"],
-    #   ["VIEW_EXPR", "win", "keepall"],
-    #   "fraud"],
-    #  ["STREAM_EXPR",
-    #   ["EVENT_FILTER_EXPR",
-    #    "PINChangeEvent",
-    #    [">", ["EVENT_PROP_EXPR", ["EVENT_PROP_SIMPLE", "size"]], "10"]],
-    #   ["VIEW_EXPR", "win", "time", ["TIME_PERIOD", ["SECOND_PART", "20"]]]],
-    #  ["WHERE_EXPR",
-    #   ["EVAL_AND_EXPR",
-    #    ["EVAL_EQUALS_EXPR",
-    #     ["LIB_FUNC_CHAIN",
-    #      ["LIB_FUNCTION", "fraud.accountNumber", "substr", "0", "8", "("]],
-    #     ["LIB_FUNC_CHAIN",
-    #      ["LIB_FUNCTION",
-    #       "substr",
-    #       ["EVENT_PROP_EXPR",
-    #        ["EVENT_PROP_SIMPLE", "PINChangeEvent"],
-    #        ["EVENT_PROP_SIMPLE", "accountNumber"]],
-    #       "0",
-    #       "8",
-    #       "("]]],
-    #    [">",
-    #     ["cast",
-    #      ["EVENT_PROP_EXPR",
-    #       ["EVENT_PROP_SIMPLE", "PINChangeEvent"],
-    #       ["EVENT_PROP_SIMPLE", "size"]],
-    #      "double"],
-    #     "10.5"]]]]
+
+    # ["startEPLExpressionRule",
+    #   ["eplExpression",
+    #     ["selectExpr",
+    #       "SELECT",
+    #       ["selectClause",
+    #         ["selectionList",
+    #           ["selectionListElement",
+    #             ["selectionListElementExpr",
+    #               ["expression",
+    #                 ["caseExpression",
+    #                   ["evalOrExpression",
+    #                     ["evalAndExpression",
+    #                       ["bitWiseExpression",
+    #                         ["negatedExpression",
+    #                           ["evalEqualsExpression",
+    #                             ["evalRelationalExpression",
+    #                               ["concatenationExpr",
+    #                                 ["additiveExpression",
+    #                                   ["multiplyExpression",
+    #                                     ["unaryExpression",
+    #                                       ["eventPropertyOrLibFunction",
+    #                                         ["libFunction",
+    #                                           ["libFunctionWithClass",
+    #                                             ["funcIdentTop", "max"],
+    #                                             "(",
+    #                                             ["libFunctionArgs",
+    #                                               ["libFunctionArgItem",
+    #                                                 ["expressionWithTime",
+    #                                                   ["expressionQualifyable",
+    #                                                     ["expression",
+    #                                                       ["caseExpression",
+    #                                                         ["evalOrExpression",
+    #                                                           ["evalAndExpression",
+    #                                                             ["bitWiseExpression",
+    #                                                               ["negatedExpression",
+    #                                                                 ["evalEqualsExpression",
+    #                                                                   ["evalRelationalExpression",
+    #                                                                     ["concatenationExpr",
+    #                                                                       ["additiveExpression",
+    #                                                                         ["multiplyExpression",
+    #                                                                           ["unaryExpression",
+    #                                                                             ["eventPropertyOrLibFunction",
+    #                                                                               ["eventProperty",
+    #                                                                                 ["eventPropertyAtomic",
+    #                                                                                   ["eventPropertyIdent",
+    #                                                                                     ["keywordAllowedIdent",
+    #                                                                                       "size"]]]]]]]]]]]]]]]]]]]]],
+    #                                             ")"]]]]]]]]]]]]]]],
+    #               "AS",
+    #               ["keywordAllowedIdent", "maxsize"]]],
+    #           ",",
+    #           ["selectionListElement",
+    #             ["selectionListElementExpr",
+    #               ["expression",
+    #                 ["caseExpression",
+    #                   ["evalOrExpression",
+    #                     ["evalAndExpression",
+    #                       ["bitWiseExpression",
+    #                         ["negatedExpression",
+    #                           ["evalEqualsExpression",
+    #                             ["evalRelationalExpression",
+    #                               ["concatenationExpr",
+    #                                 ["additiveExpression",
+    #                                   ["multiplyExpression",
+    #                                     ["unaryExpression",
+    #                                       ["eventPropertyOrLibFunction",
+    #                                         ["eventProperty",
+    #                                           ["eventPropertyAtomic",
+    #                                             ["eventPropertyIdent",
+    #                                               ["keywordAllowedIdent", "fraud"]]],
+    #                                           ".",
+    #                                           ["eventPropertyAtomic",
+    #                                             ["eventPropertyIdent",
+    #                                               ["keywordAllowedIdent", "aaa"]]]]]]]]]]]]]]]]]]],
+    #           ",",
+    #           ["selectionListElement",
+    #             ["selectionListElementExpr",
+    #               ["expression",
+    #                 ["caseExpression",
+    #                   ["evalOrExpression",
+    #                     ["evalAndExpression",
+    #                       ["bitWiseExpression",
+    #                         ["negatedExpression",
+    #                           ["evalEqualsExpression",
+    #                             ["evalRelationalExpression",
+    #                               ["concatenationExpr",
+    #                                 ["additiveExpression",
+    #                                   ["multiplyExpression",
+    #                                     ["unaryExpression",
+    #                                       ["eventPropertyOrLibFunction",
+    #                                         ["eventProperty",
+    #                                           ["eventPropertyAtomic",
+    #                                             ["eventPropertyIdent",
+    #                                               ["keywordAllowedIdent", "bbb"]]]]]]]]]]]]]]]]]]]]],
+    #       "FROM",
+    #       ["fromClause",
+    #         ["streamExpression",
+    #           ["eventFilterExpression",
+    #             ["classIdentifier", ["escapableStr", "FraudWarningEvent"]]],
+    #           ".",
+    #           ["viewExpression", "win", ":", "keepall", "(", ")"],
+    #           "AS",
+    #           "fraud"],
+    #         ["regularJoin",
+    #           ",",
+    #           ["streamExpression",
+    #             ["eventFilterExpression",
+    #               ["classIdentifier", ["escapableStr", "PINChangeEvent"]],
+    #               "(",
+    #               ["expressionList",
+    #                 ["expression",
+    #                   ["caseExpression",
+    #                     ["evalOrExpression",
+    #                       ["evalAndExpression",
+    #                         ["bitWiseExpression",
+    #                           ["negatedExpression",
+    #                             ["evalEqualsExpression",
+    #                               ["evalRelationalExpression",
+    #                                 ["concatenationExpr",
+    #                                   ["additiveExpression",
+    #                                     ["multiplyExpression",
+    #                                       ["unaryExpression",
+    #                                         ["eventPropertyOrLibFunction",
+    #                                           ["eventProperty",
+    #                                             ["eventPropertyAtomic",
+    #                                               ["eventPropertyIdent",
+    #                                                 ["keywordAllowedIdent", "size"]]]]]]]]],
+    #                                 ">",
+    #                                 ["concatenationExpr",
+    #                                   ["additiveExpression",
+    #                                     ["multiplyExpression",
+    #                                       ["unaryExpression",
+    #                                         ["constant",
+    #                                           ["numberconstant", ["number", "10"]]]]]]]]]]]]]]]],
+    #               ")"],
+    #             ".",
+    #             ["viewExpression",
+    #               "win",
+    #               ":",
+    #               "time",
+    #               "(",
+    #               ["expressionWithTimeList",
+    #                 ["expressionWithTimeInclLast",
+    #                   ["expressionWithTime",
+    #                     ["timePeriod",
+    #                       ["secondPart", ["numberconstant", ["number", "20"]], "sec"]]]]],
+    #               ")"]]]],
+    #       "WHERE",
+    #       ["whereClause",
+    #         ["evalOrExpression",
+    #           ["evalAndExpression",
+    #             ["bitWiseExpression",
+    #               ["negatedExpression",
+    #                 ["evalEqualsExpression",
+    #                   ["evalRelationalExpression",
+    #                     ["concatenationExpr",
+    #                       ["additiveExpression",
+    #                         ["multiplyExpression",
+    #                           ["unaryExpression",
+    #                             ["eventPropertyOrLibFunction",
+    #                               ["libFunction",
+    #                                 ["libFunctionWithClass",
+    #                                   ["classIdentifier",
+    #                                     ["escapableStr", "fraud"],
+    #                                     ".",
+    #                                     ["escapableStr", "accountNumber"]],
+    #                                   ".",
+    #                                   ["funcIdentTop", ["escapableIdent", "substr"]],
+    #                                   "(",
+    #                                   ["libFunctionArgs",
+    #                                     ["libFunctionArgItem",
+    #                                       ["expressionWithTime",
+    #                                         ["expressionQualifyable",
+    #                                           ["expression",
+    #                                             ["caseExpression",
+    #                                               ["evalOrExpression",
+    #                                                 ["evalAndExpression",
+    #                                                   ["bitWiseExpression",
+    #                                                     ["negatedExpression",
+    #                                                       ["evalEqualsExpression",
+    #                                                         ["evalRelationalExpression",
+    #                                                           ["concatenationExpr",
+    #                                                             ["additiveExpression",
+    #                                                               ["multiplyExpression",
+    #                                                                 ["unaryExpression",
+    #                                                                   ["constant",
+    #                                                                     ["numberconstant",
+    #                                                                       ["number", "0"]]]]]]]]]]]]]]]]]],
+    #                                     ",",
+    #                                     ["libFunctionArgItem",
+    #                                       ["expressionWithTime",
+    #                                         ["expressionQualifyable",
+    #                                           ["expression",
+    #                                             ["caseExpression",
+    #                                               ["evalOrExpression",
+    #                                                 ["evalAndExpression",
+    #                                                   ["bitWiseExpression",
+    #                                                     ["negatedExpression",
+    #                                                       ["evalEqualsExpression",
+    #                                                         ["evalRelationalExpression",
+    #                                                           ["concatenationExpr",
+    #                                                             ["additiveExpression",
+    #                                                               ["multiplyExpression",
+    #                                                                 ["unaryExpression",
+    #                                                                   ["constant",
+    #                                                                     ["numberconstant",
+    #                                                                       ["number", "8"]]]]]]]]]]]]]]]]]]],
+    #                                   ")"]]]]]]]],
+    #                   "=",
+    #                   ["evalRelationalExpression",
+    #                     ["concatenationExpr",
+    #                       ["additiveExpression",
+    #                         ["multiplyExpression",
+    #                           ["unaryExpression",
+    #                             ["eventPropertyOrLibFunction",
+    #                               ["libFunction",
+    #                                 ["libFunctionWithClass",
+    #                                   ["funcIdentTop", ["escapableIdent", "substr"]],
+    #                                   "(",
+    #                                   ["libFunctionArgs",
+    #                                     ["libFunctionArgItem",
+    #                                       ["expressionWithTime",
+    #                                         ["expressionQualifyable",
+    #                                           ["expression",
+    #                                             ["caseExpression",
+    #                                               ["evalOrExpression",
+    #                                                 ["evalAndExpression",
+    #                                                   ["bitWiseExpression",
+    #                                                     ["negatedExpression",
+    #                                                       ["evalEqualsExpression",
+    #                                                         ["evalRelationalExpression",
+    #                                                           ["concatenationExpr",
+    #                                                             ["additiveExpression",
+    #                                                               ["multiplyExpression",
+    #                                                                 ["unaryExpression",
+    #                                                                   ["eventPropertyOrLibFunction",
+    #                                                                     ["eventProperty",
+    #                                                                       ["eventPropertyAtomic",
+    #                                                                         ["eventPropertyIdent",
+    #                                                                           ["keywordAllowedIdent",
+    #                                                                             "PINChangeEvent"]]],
+    #                                                                       ".",
+    #                                                                       ["eventPropertyAtomic",
+    #                                                                         ["eventPropertyIdent",
+    #                                                                           ["keywordAllowedIdent",
+    #                                                                             "accountNumber"]]]]]]]]]]]]]]]]]]]],
+    #                                     ",",
+    #                                     ["libFunctionArgItem",
+    #                                       ["expressionWithTime",
+    #                                         ["expressionQualifyable",
+    #                                           ["expression",
+    #                                             ["caseExpression",
+    #                                               ["evalOrExpression",
+    #                                                 ["evalAndExpression",
+    #                                                   ["bitWiseExpression",
+    #                                                     ["negatedExpression",
+    #                                                       ["evalEqualsExpression",
+    #                                                         ["evalRelationalExpression",
+    #                                                           ["concatenationExpr",
+    #                                                             ["additiveExpression",
+    #                                                               ["multiplyExpression",
+    #                                                                 ["unaryExpression",
+    #                                                                   ["constant",
+    #                                                                     ["numberconstant",
+    #                                                                       ["number", "0"]]]]]]]]]]]]]]]]]],
+    #                                     ",",
+    #                                     ["libFunctionArgItem",
+    #                                       ["expressionWithTime",
+    #                                         ["expressionQualifyable",
+    #                                           ["expression",
+    #                                             ["caseExpression",
+    #                                               ["evalOrExpression",
+    #                                                 ["evalAndExpression",
+    #                                                   ["bitWiseExpression",
+    #                                                     ["negatedExpression",
+    #                                                       ["evalEqualsExpression",
+    #                                                         ["evalRelationalExpression",
+    #                                                           ["concatenationExpr",
+    #                                                             ["additiveExpression",
+    #                                                               ["multiplyExpression",
+    #                                                                 ["unaryExpression",
+    #                                                                   ["constant",
+    #                                                                     ["numberconstant",
+    #                                                                       ["number", "8"]]]]]]]]]]]]]]]]]]],
+    #                                   ")"]]]]]]]]]]],
+    #             "AND",
+    #             ["bitWiseExpression",
+    #               ["negatedExpression",
+    #                 ["evalEqualsExpression",
+    #                   ["evalRelationalExpression",
+    #                     ["concatenationExpr",
+    #                       ["additiveExpression",
+    #                         ["multiplyExpression",
+    #                           ["unaryExpression",
+    #                             ["builtinFunc",
+    #                               "cast",
+    #                               "(",
+    #                               ["expression",
+    #                                 ["caseExpression",
+    #                                   ["evalOrExpression",
+    #                                     ["evalAndExpression",
+    #                                       ["bitWiseExpression",
+    #                                         ["negatedExpression",
+    #                                           ["evalEqualsExpression",
+    #                                             ["evalRelationalExpression",
+    #                                               ["concatenationExpr",
+    #                                                 ["additiveExpression",
+    #                                                   ["multiplyExpression",
+    #                                                     ["unaryExpression",
+    #                                                       ["eventPropertyOrLibFunction",
+    #                                                         ["eventProperty",
+    #                                                           ["eventPropertyAtomic",
+    #                                                             ["eventPropertyIdent",
+    #                                                               ["keywordAllowedIdent", "PINChangeEvent"]]],
+    #                                                           ".",
+    #                                                           ["eventPropertyAtomic",
+    #                                                             ["eventPropertyIdent",
+    #                                                               ["keywordAllowedIdent", "size"]]]]]]]]]]]]]]]]],
+    #                               ",",
+    #                               ["classIdentifier", ["escapableStr", "double"]],
+    #                               ")"]]]]],
+    #                     ">",
+    #                     ["concatenationExpr",
+    #                       ["additiveExpression",
+    #                         ["multiplyExpression",
+    #                           ["unaryExpression",
+    #                             ["constant",
+    #                               ["numberconstant", ["number", "10.5"]]]]]]]]]]]]]]]],
+    #   "<EOF>"]
 
     ### SELECT count(*) AS cnt
     ### FROM TestTable.win:time_batch(10 sec)
     ### WHERE params.$$path.$1="/" AND size.$0.bytes > 100 and opts.num.seq.length() > 0
 
-    # ["EPL_EXPR",
-    #  ["SELECTION_EXPR", ["SELECTION_ELEMENT_EXPR", "count", "cnt"]],
-    #  ["STREAM_EXPR",
-    #   ["EVENT_FILTER_EXPR", "TestTable"],
-    #   ["VIEW_EXPR", "win", "time_batch", ["TIME_PERIOD", ["SECOND_PART", "10"]]]],
-    #  ["WHERE_EXPR",
-    #   ["EVAL_AND_EXPR",
-    #    ["EVAL_EQUALS_EXPR",
-    #     ["EVENT_PROP_EXPR",
-    #      ["EVENT_PROP_SIMPLE", "params"],
-    #      ["EVENT_PROP_SIMPLE", "$$path"],
-    #      ["EVENT_PROP_SIMPLE", "$1"]],
-    #     "\"/\""],
-    #    [">",
-    #     ["EVENT_PROP_EXPR",
-    #      ["EVENT_PROP_SIMPLE", "size"],
-    #      ["EVENT_PROP_SIMPLE", "$0"],
-    #      ["EVENT_PROP_SIMPLE", "bytes"]],
-    #     "100"],
-    #    [">",
-    #     ["LIB_FUNC_CHAIN", ["LIB_FUNCTION", "opts.num.seq", "length", "("]],
-    #     "0"]]]]
+    # ["startEPLExpressionRule",
+    #   ["eplExpression",
+    #     ["selectExpr",
+    #       "SELECT",
+    #       ["selectClause",
+    #         ["selectionList",
+    #           ["selectionListElement",
+    #             ["selectionListElementExpr",
+    #               ["expression",
+    #                 ["caseExpression",
+    #                   ["evalOrExpression",
+    #                     ["evalAndExpression",
+    #                       ["bitWiseExpression",
+    #                         ["negatedExpression",
+    #                           ["evalEqualsExpression",
+    #                             ["evalRelationalExpression",
+    #                               ["concatenationExpr",
+    #                                 ["additiveExpression",
+    #                                   ["multiplyExpression",
+    #                                     ["unaryExpression",
+    #                                       ["builtinFunc", "count", "(", "*", ")"]]]]]]]]]]]]],
+    #               "AS",
+    #               ["keywordAllowedIdent", "cnt"]]]]],
+    #       "FROM",
+    #       ["fromClause",
+    #         ["streamExpression",
+    #           ["eventFilterExpression",
+    #             ["classIdentifier", ["escapableStr", "TestTable"]]],
+    #           ".",
+    #           ["viewExpression",
+    #             "win",
+    #             ":",
+    #             "time_batch",
+    #             "(",
+    #             ["expressionWithTimeList",
+    #               ["expressionWithTimeInclLast",
+    #                 ["expressionWithTime",
+    #                   ["timePeriod",
+    #                     ["secondPart", ["numberconstant", ["number", "10"]], "sec"]]]]],
+    #             ")"]],
+    #         "regularJoin"],
+    #       "WHERE",
+    #       ["whereClause",
+    #         ["evalOrExpression",
+    #           ["evalAndExpression",
+    #             ["bitWiseExpression",
+    #               ["negatedExpression",
+    #                 ["evalEqualsExpression",
+    #                   ["evalRelationalExpression",
+    #                     ["concatenationExpr",
+    #                       ["additiveExpression",
+    #                         ["multiplyExpression",
+    #                           ["unaryExpression",
+    #                             ["eventPropertyOrLibFunction",
+    #                               ["eventProperty",
+    #                                 ["eventPropertyAtomic",
+    #                                   ["eventPropertyIdent", ["keywordAllowedIdent", "params"]]],
+    #                                 ".",
+    #                                 ["eventPropertyAtomic",
+    #                                   ["eventPropertyIdent", ["keywordAllowedIdent", "$$path"]]],
+    #                                 ".",
+    #                                 ["eventPropertyAtomic",
+    #                                   ["eventPropertyIdent", ["keywordAllowedIdent", "$1"]]]]]]]]]],
+    #                   "=",
+    #                   ["evalRelationalExpression",
+    #                     ["concatenationExpr",
+    #                       ["additiveExpression",
+    #                         ["multiplyExpression",
+    #                           ["unaryExpression",
+    #                             ["constant", ["stringconstant", "\"/\""]]]]]]]]]],
+    #             "AND",
+    #             ["bitWiseExpression",
+    #               ["negatedExpression",
+    #                 ["evalEqualsExpression",
+    #                   ["evalRelationalExpression",
+    #                     ["concatenationExpr",
+    #                       ["additiveExpression",
+    #                         ["multiplyExpression",
+    #                           ["unaryExpression",
+    #                             ["eventPropertyOrLibFunction",
+    #                               ["eventProperty",
+    #                                 ["eventPropertyAtomic",
+    #                                   ["eventPropertyIdent", ["keywordAllowedIdent", "size"]]],
+    #                                 ".",
+    #                                 ["eventPropertyAtomic",
+    #                                   ["eventPropertyIdent", ["keywordAllowedIdent", "$0"]]],
+    #                                 ".",
+    #                                 ["eventPropertyAtomic",
+    #                                   ["eventPropertyIdent",
+    #                                     ["keywordAllowedIdent", "bytes"]]]]]]]]],
+    #                     ">",
+    #                     ["concatenationExpr",
+    #                       ["additiveExpression",
+    #                         ["multiplyExpression",
+    #                           ["unaryExpression",
+    #                             ["constant", ["numberconstant", ["number", "100"]]]]]]]]]]],
+    #             "and",
+    #             ["bitWiseExpression",
+    #               ["negatedExpression",
+    #                 ["evalEqualsExpression",
+    #                   ["evalRelationalExpression",
+    #                     ["concatenationExpr",
+    #                       ["additiveExpression",
+    #                         ["multiplyExpression",
+    #                           ["unaryExpression",
+    #                             ["eventPropertyOrLibFunction",
+    #                               ["libFunction",
+    #                                 ["libFunctionWithClass",
+    #                                   ["classIdentifier",
+    #                                     ["escapableStr", "opts"],
+    #                                     ".",
+    #                                     ["escapableStr", "num"],
+    #                                     ".",
+    #                                     ["escapableStr", "seq"]],
+    #                                   ".",
+    #                                   ["funcIdentTop", ["escapableIdent", "length"]],
+    #                                   "(",
+    #                                   ")"]]]]]]],
+    #                     ">",
+    #                     ["concatenationExpr",
+    #                       ["additiveExpression",
+    #                         ["multiplyExpression",
+    #                           ["unaryExpression",
+    #                             ["constant", ["numberconstant", ["number", "0"]]]]]]]]]]]]]]]],
+    #   "<EOF>"]
 
     ### SELECT a.name, a.content, b.content
     ### FROM pattern[every a=EventA -> b=EventA(name = a.name, type = 'TYPE') WHERE timer:within(1 min)].win:time(2 hour)
     ### WHERE a.source in ('A', 'B')
 
-    # ["EPL_EXPR",
-    #   ["SELECTION_EXPR",
-    #     ["SELECTION_ELEMENT_EXPR",
-    #       ["EVENT_PROP_EXPR",
-    #         ["EVENT_PROP_SIMPLE", "a"],
-    #         ["EVENT_PROP_SIMPLE", "name"]]],
-    #     ["SELECTION_ELEMENT_EXPR",
-    #       ["EVENT_PROP_EXPR",
-    #         ["EVENT_PROP_SIMPLE", "a"],
-    #         ["EVENT_PROP_SIMPLE", "content"]]],
-    #     ["SELECTION_ELEMENT_EXPR",
-    #       ["EVENT_PROP_EXPR",
-    #         ["EVENT_PROP_SIMPLE", "b"],
-    #         ["EVENT_PROP_SIMPLE", "content"]]]],
-    #   ["STREAM_EXPR",
-    #     ["PATTERN_INCL_EXPR",
-    #       ["FOLLOWED_BY_EXPR",
-    #         ["FOLLOWED_BY_ITEM", ["every", ["PATTERN_FILTER_EXPR", "a", "EventA"]]],
-    #         ["FOLLOWED_BY_ITEM",
-    #           ["GUARD_EXPR",
-    #             ["PATTERN_FILTER_EXPR",
-    #               "b",
-    #               "EventA",
-    #               ["EVAL_EQUALS_EXPR",
-    #                 ["EVENT_PROP_EXPR", ["EVENT_PROP_SIMPLE", "name"]],
-    #                 ["EVENT_PROP_EXPR",
-    #                   ["EVENT_PROP_SIMPLE", "a"],
-    #                   ["EVENT_PROP_SIMPLE", "name"]]],
-    #               ["EVAL_EQUALS_EXPR",
-    #                 ["EVENT_PROP_EXPR", ["EVENT_PROP_SIMPLE", "type"]],
-    #                 "'TYPE'"]],
-    #             "timer",
-    #             "within",
-    #             ["TIME_PERIOD", ["MINUTE_PART", "1"]]]]]],
-    #     ["VIEW_EXPR", "win", "time", ["TIME_PERIOD", ["HOUR_PART", "2"]]]],
-    #   ["WHERE_EXPR",
-    #     ["in",
-    #       ["EVENT_PROP_EXPR",
-    #         ["EVENT_PROP_SIMPLE", "a"],
-    #         ["EVENT_PROP_SIMPLE", "source"]],
-    #       "(",
-    #       "'A'",
-    #       "'B'",
-    #       ")"]]]
+    # ["startEPLExpressionRule",
+    #   ["eplExpression",
+    #     ["selectExpr",
+    #       "SELECT",
+    #       ["selectClause",
+    #         ["selectionList",
+    #           ["selectionListElement",
+    #             ["selectionListElementExpr",
+    #               ["expression",
+    #                 ["caseExpression",
+    #                   ["evalOrExpression",
+    #                     ["evalAndExpression",
+    #                       ["bitWiseExpression",
+    #                         ["negatedExpression",
+    #                           ["evalEqualsExpression",
+    #                             ["evalRelationalExpression",
+    #                               ["concatenationExpr",
+    #                                 ["additiveExpression",
+    #                                   ["multiplyExpression",
+    #                                     ["unaryExpression",
+    #                                       ["eventPropertyOrLibFunction",
+    #                                         ["eventProperty",
+    #                                           ["eventPropertyAtomic",
+    #                                             ["eventPropertyIdent", ["keywordAllowedIdent", "a"]]],
+    #                                           ".",
+    #                                           ["eventPropertyAtomic",
+    #                                             ["eventPropertyIdent",
+    #                                               ["keywordAllowedIdent", "name"]]]]]]]]]]]]]]]]]]],
+    #           ",",
+    #           ["selectionListElement",
+    #             ["selectionListElementExpr",
+    #               ["expression",
+    #                 ["caseExpression",
+    #                   ["evalOrExpression",
+    #                     ["evalAndExpression",
+    #                       ["bitWiseExpression",
+    #                         ["negatedExpression",
+    #                           ["evalEqualsExpression",
+    #                             ["evalRelationalExpression",
+    #                               ["concatenationExpr",
+    #                                 ["additiveExpression",
+    #                                   ["multiplyExpression",
+    #                                     ["unaryExpression",
+    #                                       ["eventPropertyOrLibFunction",
+    #                                         ["eventProperty",
+    #                                           ["eventPropertyAtomic",
+    #                                             ["eventPropertyIdent", ["keywordAllowedIdent", "a"]]],
+    #                                           ".",
+    #                                           ["eventPropertyAtomic",
+    #                                             ["eventPropertyIdent",
+    #                                               ["keywordAllowedIdent", "content"]]]]]]]]]]]]]]]]]]],
+    #           ",",
+    #           ["selectionListElement",
+    #             ["selectionListElementExpr",
+    #               ["expression",
+    #                 ["caseExpression",
+    #                   ["evalOrExpression",
+    #                     ["evalAndExpression",
+    #                       ["bitWiseExpression",
+    #                         ["negatedExpression",
+    #                           ["evalEqualsExpression",
+    #                             ["evalRelationalExpression",
+    #                               ["concatenationExpr",
+    #                                 ["additiveExpression",
+    #                                   ["multiplyExpression",
+    #                                     ["unaryExpression",
+    #                                       ["eventPropertyOrLibFunction",
+    #                                         ["eventProperty",
+    #                                           ["eventPropertyAtomic",
+    #                                             ["eventPropertyIdent", ["keywordAllowedIdent", "b"]]],
+    #                                           ".",
+    #                                           ["eventPropertyAtomic",
+    #                                             ["eventPropertyIdent",
+    #                                               ["keywordAllowedIdent", "content"]]]]]]]]]]]]]]]]]]]]],
+    #       "FROM",
+    #       ["fromClause",
+    #         ["streamExpression",
+    #           ["patternInclusionExpression",
+    #             "pattern",
+    #             "[",
+    #             ["patternExpression",
+    #               ["followedByExpression",
+    #                 ["orExpression",
+    #                   ["andExpression",
+    #                     ["matchUntilExpression",
+    #                       ["qualifyExpression",
+    #                         "every",
+    #                         ["guardPostFix",
+    #                           ["atomicExpression",
+    #                             ["patternFilterExpression",
+    #                               "a",
+    #                               "=",
+    #                               ["classIdentifier", ["escapableStr", "EventA"]]]]]]]]],
+    #                 ["followedByRepeat",
+    #                   "->",
+    #                   ["orExpression",
+    #                     ["andExpression",
+    #                       ["matchUntilExpression",
+    #                         ["qualifyExpression",
+    #                           ["guardPostFix",
+    #                             ["atomicExpression",
+    #                               ["patternFilterExpression",
+    #                                 "b",
+    #                                 "=",
+    #                                 ["classIdentifier", ["escapableStr", "EventA"]],
+    #                                 "(",
+    #                                 ["expressionList",
+    #                                   ["expression",
+    #                                     ["caseExpression",
+    #                                       ["evalOrExpression",
+    #                                         ["evalAndExpression",
+    #                                           ["bitWiseExpression",
+    #                                             ["negatedExpression",
+    #                                               ["evalEqualsExpression",
+    #                                                 ["evalRelationalExpression",
+    #                                                   ["concatenationExpr",
+    #                                                     ["additiveExpression",
+    #                                                       ["multiplyExpression",
+    #                                                         ["unaryExpression",
+    #                                                           ["eventPropertyOrLibFunction",
+    #                                                             ["eventProperty",
+    #                                                               ["eventPropertyAtomic",
+    #                                                                 ["eventPropertyIdent",
+    #                                                                   ["keywordAllowedIdent", "name"]]]]]]]]]],
+    #                                                 "=",
+    #                                                 ["evalRelationalExpression",
+    #                                                   ["concatenationExpr",
+    #                                                     ["additiveExpression",
+    #                                                       ["multiplyExpression",
+    #                                                         ["unaryExpression",
+    #                                                           ["eventPropertyOrLibFunction",
+    #                                                             ["eventProperty",
+    #                                                               ["eventPropertyAtomic",
+    #                                                                 ["eventPropertyIdent",
+    #                                                                   ["keywordAllowedIdent", "a"]]],
+    #                                                               ".",
+    #                                                               ["eventPropertyAtomic",
+    #                                                                 ["eventPropertyIdent",
+    #                                                                   ["keywordAllowedIdent",
+    #                                                                     "name"]]]]]]]]]]]]]]]]],
+    #                                   ",",
+    #                                   ["expression",
+    #                                     ["caseExpression",
+    #                                       ["evalOrExpression",
+    #                                         ["evalAndExpression",
+    #                                           ["bitWiseExpression",
+    #                                             ["negatedExpression",
+    #                                               ["evalEqualsExpression",
+    #                                                 ["evalRelationalExpression",
+    #                                                   ["concatenationExpr",
+    #                                                     ["additiveExpression",
+    #                                                       ["multiplyExpression",
+    #                                                         ["unaryExpression",
+    #                                                           ["eventPropertyOrLibFunction",
+    #                                                             ["eventProperty",
+    #                                                               ["eventPropertyAtomic",
+    #                                                                 ["eventPropertyIdent",
+    #                                                                   ["keywordAllowedIdent", "type"]]]]]]]]]],
+    #                                                 "=",
+    #                                                 ["evalRelationalExpression",
+    #                                                   ["concatenationExpr",
+    #                                                     ["additiveExpression",
+    #                                                       ["multiplyExpression",
+    #                                                         ["unaryExpression",
+    #                                                           ["constant",
+    #                                                             ["stringconstant", "'TYPE'"]]]]]]]]]]]]]]],
+    #                                 ")"]],
+    #                             "WHERE",
+    #                             ["guardWhereExpression",
+    #                               "timer",
+    #                               ":",
+    #                               "within",
+    #                               "(",
+    #                               ["expressionWithTimeList",
+    #                                 ["expressionWithTimeInclLast",
+    #                                   ["expressionWithTime",
+    #                                     ["timePeriod",
+    #                                       ["minutePart",
+    #                                         ["numberconstant", ["number", "1"]],
+    #                                         "min"]]]]],
+    #                               ")"]]]]]]]]],
+    #             "]"],
+    #           ".",
+    #           ["viewExpression",
+    #             "win",
+    #             ":",
+    #             "time",
+    #             "(",
+    #             ["expressionWithTimeList",
+    #               ["expressionWithTimeInclLast",
+    #                 ["expressionWithTime",
+    #                   ["timePeriod",
+    #                     ["hourPart", ["numberconstant", ["number", "2"]], "hour"]]]]],
+    #             ")"]],
+    #         "regularJoin"],
+    #       "WHERE",
+    #       ["whereClause",
+    #         ["evalOrExpression",
+    #           ["evalAndExpression",
+    #             ["bitWiseExpression",
+    #               ["negatedExpression",
+    #                 ["evalEqualsExpression",
+    #                   ["evalRelationalExpression",
+    #                     ["concatenationExpr",
+    #                       ["additiveExpression",
+    #                         ["multiplyExpression",
+    #                           ["unaryExpression",
+    #                             ["eventPropertyOrLibFunction",
+    #                               ["eventProperty",
+    #                                 ["eventPropertyAtomic",
+    #                                   ["eventPropertyIdent", ["keywordAllowedIdent", "a"]]],
+    #                                 ".",
+    #                                 ["eventPropertyAtomic",
+    #                                   ["eventPropertyIdent",
+    #                                     ["keywordAllowedIdent", "source"]]]]]]]]],
+    #                     "in",
+    #                     "(",
+    #                     ["expression",
+    #                       ["caseExpression",
+    #                         ["evalOrExpression",
+    #                           ["evalAndExpression",
+    #                             ["bitWiseExpression",
+    #                               ["negatedExpression",
+    #                                 ["evalEqualsExpression",
+    #                                   ["evalRelationalExpression",
+    #                                     ["concatenationExpr",
+    #                                       ["additiveExpression",
+    #                                         ["multiplyExpression",
+    #                                           ["unaryExpression",
+    #                                             ["constant", ["stringconstant", "'A'"]]]]]]]]]]]]]],
+    #                     ",",
+    #                     ["expression",
+    #                       ["caseExpression",
+    #                         ["evalOrExpression",
+    #                           ["evalAndExpression",
+    #                             ["bitWiseExpression",
+    #                               ["negatedExpression",
+    #                                 ["evalEqualsExpression",
+    #                                   ["evalRelationalExpression",
+    #                                     ["concatenationExpr",
+    #                                       ["additiveExpression",
+    #                                         ["multiplyExpression",
+    #                                           ["unaryExpression",
+    #                                             ["constant", ["stringconstant", "'B'"]]]]]]]]]]]]]],
+    #                     ")"]]]]]]]]],
+    #   "<EOF>"]
 
     def astnode(tree)
-      children = if tree.children
-                   tree.children.map{|c| astnode(c)}
-                 else
-                   []
-                 end
-      cls = case tree.text
-            when 'EVENT_PROP_EXPR' then ASTEventPropNode
-            when 'SELECTION_ELEMENT_EXPR' then ASTSelectionElementNode
-            when 'LIB_FUNCTION' then ASTLibFunctionNode
-            when 'STREAM_EXPR' then ASTStreamNode
-            when 'PATTERN_FILTER_EXPR' then ASTPatternNode
-            when 'SUBSELECT_EXPR' then ASTSubSelectNode
+      # com.espertech.esper.epl.generated.EsperEPL2GrammarParser.ruleNames[ast.ruleIndex] #=> "startEPLExpressionRule"
+      # com.espertech.esper.epl.generated.EsperEPL2GrammarParser.ruleNames[ast.getChild(0).ruleIndex] #=> "eplExpression"
+
+      # ast.getChild(0).getChild(0).ruleIndex #=> 15
+      # com.espertech.esper.epl.generated.EsperEPL2GrammarParser.ruleNames[ast.getChild(0).getChild(0).ruleIndex] #=> "selectExpr"
+      # ast.getChild(0).getChild(0).getChild(0).symbol.text #=> 'select'
+      # ast.getChild(0).getChild(0).getChild(0).symbol.type #=> 24
+
+      # [23] pry(main)> ast.getChild(0).getChild(1)
+      # => nil
+      # [24] pry(main)> ast.getChild(0).getChild(0).getChild(1)
+      # => #<Java::ComEspertechEsperEplGenerated::EsperEPL2GrammarParser::SelectClauseContext:0x6437693>
+      # [25] pry(main)> ast.getChild(0).getChild(0).getChild(1).getChild(0)
+      # => #<Java::ComEspertechEsperEplGenerated::EsperEPL2GrammarParser::SelectionListContext:0x5de28c04>
+
+      name = if tree.respond_to?(:getRuleIndex)
+               Java::ComEspertechEsperEplGenerated::EsperEPL2GrammarParser.ruleNames[tree.getRuleIndex]
+             else
+               tree.symbol.text
+             end
+      children = []
+      tree.childCount.times do |i|
+        child = tree.getChild(i)
+        children << astnode(child) if child
+      end
+
+      cls = case name
+            when 'eventProperty' then ASTEventPropNode
+            when 'selectionListElementExpr' then ASTSelectionElementNode
+            when 'libFunction' then ASTLibFunctionNode
+            when 'streamExpression', 'subSelectFilterExpr' then ASTStreamNode
+            when 'patternFilterExpression' then ASTPatternNode
+            when 'subQueryExpr' then ASTSubSelectNode
             else ASTNode
             end
       if cls.respond_to?(:generate)
-        cls.generate(tree.text, children, tree)
+        cls.generate(name, children, tree)
       else
-        cls.new(tree.text, children, tree)
+        cls.new(name, children, tree)
       end
     end
 
@@ -203,117 +813,292 @@ module Norikra
       end
     end
 
-    class ASTEventPropNode < ASTNode # EVENT_PROP_EXPR
-      # "bbb"           => ["EVENT_PROP_EXPR", ["EVENT_PROP_SIMPLE", "bbb"]]
-      # "fraud.aaa"     => ["EVENT_PROP_EXPR", ["EVENT_PROP_SIMPLE", "fraud"], ["EVENT_PROP_SIMPLE", "aaa"]]
-      # "size.$0.bytes" => ["EVENT_PROP_EXPR", ["EVENT_PROP_SIMPLE", "size"],  ["EVENT_PROP_SIMPLE", "$0"], ["EVENT_PROP_SIMPLE", "bytes"]]
-      # "field.index("?")" => ["EVENT_PROP_EXPR", ["EVENT_PROP_SIMPLE", "path"], ["EVENT_PROP_MAPPED", "index", "\"?\""]]
-      # "field.f1.index(".")" => ["EVENT_PROP_EXPR", ["EVENT_PROP_SIMPLE", "path"], ["EVENT_PROP_SIMPLE", "q1"], ["EVENT_PROP_MAPPED", "index", "\".\""]]
+    class ASTEventPropNode < ASTNode # eventProperty
+      ### "a"
+      # ["eventProperty", ["eventPropertyAtomic", ["eventPropertyIdent", ["keywordAllowedIdent", "a"]]]
+
+      ### "fraud.aaa"
+      # ["eventProperty",
+      #   ["eventPropertyAtomic", ["eventPropertyIdent", ["keywordAllowedIdent", "fraud"]]],
+      #   ".",
+      #   ["eventPropertyAtomic", ["eventPropertyIdent", ["keywordAllowedIdent", "aaa"]]]]
+
+      ### "size.$0.bytes"
+      # ["eventProperty",
+      #   ["eventPropertyAtomic", ["eventPropertyIdent", ["keywordAllowedIdent", "size"]]],
+      #   ".",
+      #   ["eventPropertyAtomic", ["eventPropertyIdent", ["keywordAllowedIdent", "$0"]]],
+      #   ".",
+      #   ["eventPropertyAtomic", ["eventPropertyIdent", ["keywordAllowedIdent", "bytes"]]]]
+
+      ### "field.index("?")"
+      # ["eventProperty",
+      #   ["eventPropertyAtomic", ["eventPropertyIdent", ["keywordAllowedIdent", "field"]]],
+      #   ".",
+      #   ["eventPropertyAtomic", ["eventPropertyIdent", ["keywordAllowedIdent", "index"]], "(", "'?'", ")"]]
+
+      ### "field.f1.index(".")"
+      # ["eventProperty",
+      #   ["eventPropertyAtomic", ["eventPropertyIdent", ["keywordAllowedIdent", "field"]]],
+      #   ".",
+      #   ["eventPropertyAtomic", ["eventPropertyIdent", ["keywordAllowedIdent", "f1"]]],
+      #   ".",
+      #   ["eventPropertyAtomic", ["eventPropertyIdent", ["keywordAllowedIdent", "index"]], "(", "'.'", ")"]]
 
       #### escapes: Oops!!!! unsupported yet.
-      # "`path name`" => ["EVENT_PROP_EXPR", ["EVENT_PROP_SIMPLE", "`path name`"]]
-      # "`T Table`.`path name`" => ["EVENT_PROP_EXPR", ["EVENT_PROP_SIMPLE", "`T Testing`"], ["EVENT_PROP_SIMPLE", "`path name`"]]
-      # "`size.num`" => ["EVENT_PROP_EXPR", ["EVENT_PROP_SIMPLE", "`size.num`"]]
+
+      ### "`path name`"
+      #    ["eventProperty", ["eventPropertyAtomic", ["eventPropertyIdent", ["keywordAllowedIdent", "`field name`"]]]]
+
+      ### "`T Table`.`path name`"
+      # ["eventProperty",
+      #   ["eventPropertyAtomic", ["eventPropertyIdent", ["keywordAllowedIdent", "`T table`"]]],
+      #   ".",
+      #   ["eventPropertyAtomic", ["eventPropertyIdent", ["keywordAllowedIdent", "`path name`"]]]]
+
+      ### "`size.num`"
+      # ["eventProperty", ["eventPropertyAtomic", ["eventPropertyIdent", ["keywordAllowedIdent", "`size.num`"]]]]
 
       def nodetype?(*sym)
         sym.include?(:prop) || sym.include?(:property)
       end
 
       def fields(default_target=nil, known_targets_aliases=[])
-        props = self.listup('EVENT_PROP_SIMPLE')
+        props = self.listup('eventPropertyAtomic')
+        leading_name = props[0].find('eventPropertyIdent').find('keywordAllowedIdent').child.name
+
         if props.size > 1 # alias.fieldname or container_fieldname.key.$1 or fieldname.method(...)
-          if known_targets_aliases.include?(props[0].child.name)
-            [ {:f => props[1..-1].map{|n| n.child.name}.join("."), :t => props[0].child.name} ]
+          non_calls = props.select{|p| p.children.size == 1 }.map{|p| p.find('eventPropertyIdent').find('keywordAllowedIdent').child.name }
+          if known_targets_aliases.include?(leading_name)
+            [ {:f => non_calls[1..-1].join("."), :t => leading_name} ]
           else
-            [ {:f => props.map{|n| n.child.name}.join("."), :t => default_target} ]
+            [ {:f => non_calls.join("."), :t => default_target} ]
           end
         else # fieldname (default target)
-          [ {:f => props[0].child.name, :t => default_target } ]
+          # ["eventProperty", ["eventPropertyAtomic", ["eventPropertyIdent", ["keywordAllowedIdent", "a"]]]
+          [ {:f => leading_name, :t => default_target } ]
         end
       end
     end
 
-    class ASTSelectionElementNode < ASTNode # SELECTION_ELEMENT_EXPR
-      # "count(*) AS cnt"  => ["SELECTION_ELEMENT_EXPR", "count", "cnt"]
-      # "n.s as s"         => ["SELECTION_ELEMENT_EXPR", ["EVENT_PROP_EXPR", ["EVENT_PROP_SIMPLE", "n"], ["EVENT_PROP_SIMPLE", "s"]], "s"]
+    class ASTSelectionElementNode < ASTNode # selectionListElementExpr
+      ### "s"
+      # ["selectionListElement",
+      #   ["selectionListElementExpr",
+      #     ["expression",
+      #       ["caseExpression", ["evalOrExpression", ["evalAndExpression", ["bitWiseExpression", ["negatedExpression",
+      #         ["evalEqualsExpression", ["evalRelationalExpression", ["concatenationExpr", ["additiveExpression",
+      #           ["multiplyExpression", ["unaryExpression", ["eventPropertyOrLibFunction",
+      #             ["eventProperty",
+      #               ["eventPropertyAtomic", ["eventPropertyIdent", ["keywordAllowedIdent", "s"]]]]]]]]]]]]]]]]]]]
+
+      ### "count(*) AS cnt"  => ["SELECTION_ELEMENT_EXPR", "count", "cnt"]
+      # ["selectionListElementExpr",
+      #   ["expression",
+      #     ["caseExpression", ["evalOrExpression", ["evalAndExpression", ["bitWiseExpression", ["negatedExpression",
+      #       ["evalEqualsExpression", ["evalRelationalExpression", ["concatenationExpr", ["additiveExpression",
+      #         ["multiplyExpression", ["unaryExpression",
+      #           ["builtinFunc", "count", "(", "*", ")"]]]]]]]]]]]]],
+      #   "AS",
+      #   ["keywordAllowedIdent", "cnt"]]
+
+      ### "n.s as s"
+      # ["selectionListElementExpr",
+      #   ["expression",
+      #     ["caseExpression", ["evalOrExpression", ["evalAndExpression", ["bitWiseExpression", ["negatedExpression",
+      #       ["evalEqualsExpression", ["evalRelationalExpression", ["concatenationExpr", ["additiveExpression",
+      #         ["multiplyExpression", ["unaryExpression", ["eventPropertyOrLibFunction",
+      #           ["eventProperty",
+      #             ["eventPropertyAtomic", ["eventPropertyIdent", ["keywordAllowedIdent", "n"]]],
+      #             ".",
+      #             ["eventPropertyAtomic", ["eventPropertyIdent", ["keywordAllowedIdent", "s"]]]]]]]]]]]]]]]]],
+      #   "as",
+      #   ["keywordAllowedIdent", "s"]]]
+
       def nodetype?(*sym)
         sym.include?(:selection)
       end
 
       def alias
-        @children.size == 2 ? @children[1].name : nil
+        @children.size == 3 && @children[1].name.downcase == 'as' ? @children[2].child.name : nil
       end
     end
 
     class ASTLibFunctionNode < ASTNode # LIB_FUNCTION
       ### foo is function
-      # "foo()"     => ["LIB_FUNCTION", "foo", "("]
-      # "foo(10)"   => ["LIB_FUNCTION", "foo", "10", "("]
-      # "foo(10,0)" => ["LIB_FUNCTION", "foo", "10", "0", "("]
-      # "foo(bar)"  => ["LIB_FUNCTION", "foo", ["EVENT_PROP_EXPR", ["EVENT_PROP_SIMPLE", "bar"]], "("]
+      # "foo()"     => ["libFunction", ["libFunctionWithClass", ["funcIdentTop", ["escapableIdent", "foo"]], "(", ")"]]
+
+      ### "foo(10)"
+      # ["libFunction",
+      #   ["libFunctionWithClass",
+      #     ["funcIdentTop", ["escapableIdent", "foo"]],
+      #     "(",
+      #     ["libFunctionArgs",
+      #       ["libFunctionArgItem", ["expressionWithTime", ["expressionQualifyable", ["expression", EXPRESSION... ]]]]]
+      #     ")"]]
+
+      ### "foo(10,0)"
+      # ["libFunction",
+      #   ["libFunctionWithClass",
+      #     ["funcIdentTop", ["escapableIdent", "foo"]],
+      #     "(",
+      #     ["libFunctionArgs",
+      #       ["libFunctionArgItem", ["expressionWithTime", ["expressionQualifyable", ["expression", EXPRESSION... ]]]],
+      #       ",",
+      #       ["libFunctionArgItem", ["expressionWithTime", ["expressionQualifyable", ["expression", EXPRESSION... ]]]]],
+      #     ")"]]
 
       ### foo is property
-      # "foo.bar()"    => ["LIB_FUNCTION", "foo", "bar", "("]
-      # "foo.bar(0)"   => ["LIB_FUNCTION", "foo", "bar", "0", "("]
-      # "foo.bar(0,8)" => ["LIB_FUNCTION", "foo", "bar", "0", "8", "("]
+      ### "foo.bar()"
+      # ["libFunction",
+      #   ["libFunctionWithClass",
+      #     ["classIdentifier", ["escapableStr", "foo"]],
+      #     ".",
+      #     ["funcIdentTop", ["escapableIdent", "bar"]],
+      #     "(",
+      #     ")"]]
 
-      ### nested field access
-      # "foo.bar.$0.baz()" => ["LIB_FUNCTION", "foo.bar.$0", "baz", "("]
+      ### Math.abs()
+      # ["libFunction",
+      #   ["libFunctionWithClass",
+      #     ["classIdentifier", ["escapableStr", "Math"]],
+      #     ".",
+      #     ["funcIdentTop", ["escapableIdent", "abs"]],
+      #     "(",
+      #     ["libFunctionArgs",
+      #       ["libFunctionArgItem",
+      #         ["expressionWithTime",
+      #           ["expression", EXPRESSION... ]]]],
+      #     ")"]]
 
-      # 2nd child is bare-word (like [a-z][a-z0-9]*) -> this is function -> 1st child is receiver -> property
-      # 2nd child is literal or property or none -> 1st child is built-in function
+      ### "foo.bar(0)"
+      # ["libFunction",
+      #   ["libFunctionWithClass",
+      #     ["classIdentifier", ["escapableStr", "foo"]],
+      #     ".",
+      #     ["funcIdentTop", ["escapableIdent", "bar"]],
+      #     "(",
+      #     ["libFunctionArgs",
+      #       ["libFunctionArgItem",
+      #         ["expressionWithTime",
+      #           ["expressionQualifyable",
+      #             ["expression", EXPRESSION....
+      #               ["constant", ["numberconstant", ["number", "0"]]]]]]]],
+      #     ")"]]
+
+      ### chain
+      ### "field.substr(0).length()"
+      # ["libFunction",
+      #   ["libFunctionWithClass",
+      #     ["classIdentifier", ["escapableStr", "field"]],
+      #     ".",
+      #     ["funcIdentTop", ["escapableIdent", "substr"]],
+      #     "(",
+      #     ["libFunctionArgs",
+      #       ["libFunctionArgItem",
+      #         ["expressionWithTime",
+      #           ["expressionQualifyable",
+      #             ["expression", EXPRESSION...,
+      #               ["constant", ["numberconstant", ["number", "0"]]]]]]]],
+      #     ")"],
+      #   ".",
+      #   ["libFunctionNoClass",
+      #     ["funcIdentChained", ["escapableIdent", "length"]],
+      #     "(",
+      #     ")"]]
+
+      ### nested function call
+      # ["libFunction",
+      #   ["libFunctionWithClass",
+      #     ["classIdentifier", ["escapableStr", "Math"]],
+      #     ".",
+      #     ["funcIdentTop", ["escapableIdent", "abs"]],
+      #     "(",
+      #     ["libFunctionArgs",
+      #       ["libFunctionArgItem",
+      #         ["expressionWithTime",
+      #           ["expressionQualifyable",
+      #             ["expression", EXPRESSION...,
+      #               ["eventPropertyOrLibFunction",
+      #                 ["libFunction",
+      #                   ["libFunctionWithClass",
+      #                     ["classIdentifier",
+      #                       ["escapableStr", "Math"]],
+      #                     ".",
+      #                     ["funcIdentTop",
+      #                       ["escapableIdent", "abs"]],
+      #                     "(",
+      #                     ["libFunctionArgs",
+      #                       ["libFunctionArgItem",
+      #                         ["expressionWithTime",
+      #                           ["expressionQualifyable",
+      #                             ["expression", EXPRESSION...,
+      #                               ["eventPropertyOrLibFunction",
+      #                                 ["eventProperty",
+      #                                   ["eventPropertyAtomic", ["eventPropertyIdent", ["keywordAllowedIdent", "a"]]]]]]]]]],
+      #                     ")"]]]]]]]],
+      #     ")"]]
+
+      ### nested field access
+      ### "foo.bar.$0.baz()"
+      # ["libFunction",
+      #   ["libFunctionWithClass",
+      #     ["classIdentifier",
+      #       ["escapableStr", "foo"],
+      #       ".",
+      #       ["escapableStr", "bar"],
+      #       ".",
+      #       ["escapableStr", "$0"]],
+      #     ".",
+      #     ["funcIdentTop", ["escapableIdent", "baz"]],
+      #     "(",
+      #     ")"]]
 
       ### escaped name access
-      # "`T Table`.param.length()" => ["LIB_FUNC_CHAIN", ["LIB_FUNCTION", "TestTable Testing.param", "length", "("]]
-      ## Oops! we CANNOT support this syntax
+      # "`T Table`.param.length()"
+      # ["libFunction",
+      #   ["libFunctionWithClass",
+      #     ["classIdentifier",
+      #       ["escapableStr", "`T Table`"],
+      #       ".",
+      #       ["escapableStr", "param"]],
+      #     ".",
+      #     ["funcIdentTop", ["escapableIdent", "length"]],
+      #     "(",
+      #     ")"]]
 
       def nodetype?(*sym)
         sym.include?(:lib) || sym.include?(:libfunc)
       end
 
       def fields(default_target=nil, known_targets_aliases=[])
-        if @children.size <= 2
-          # single function like 'now()', function-name and "("
-          []
+        identifier = self.find("classIdentifier")
 
-        elsif @children[1].nodetype?(:prop, :lib, :subquery)
-          # first element should be func name if second element is property, library call or subqueries
-          self.listup('EVENT_PROP_EXPR').map{|c| c.fields(default_target, known_targets_aliases)}.reduce(&:+) || []
+        return [] if identifier.nil? # built-in function call (no receivers exists)
 
-        elsif @children[1].name =~ /^(-)?\d+(\.\d+)?$/ || @children[1].name =~ /^'[^']*'$/ || @children[1].name =~ /^"[^"]*"$/
-          # first element should be func name if secod element is number/string literal
-          self.listup('EVENT_PROP_EXPR').map{|c| c.fields(default_target, known_targets_aliases)}.reduce(&:+) || []
-
-        elsif Norikra::Query.imported_java_class?(@children[0].name)
+        if identifier.children.size == 1 && Norikra::Query.imported_java_class?(identifier.find("escapableStr").child.name)
           # Java imported class name (ex: 'Math.abs(-1)')
-          self.listup('EVENT_PROP_EXPR').map{|c| c.fields(default_target, known_targets_aliases)}.reduce(&:+) || []
-
+          self.listup(:prop).map{|c| c.fields(default_target, known_targets_aliases)}.reduce(&:+) || []
         else
-          # first element may be property ########## or function
-          #  * simple 'fieldname.funcname()'
-          #  * fully qualified 'target.fieldname.funcname()'
-          #  * simple/fully-qualified container field access 'fieldname.key.$0.funcname()' or 'target.fieldname.$1.funcname()'
-          target,fieldname = if @children[0].name.include?('.')
-                               parts = @children[0].name.split('.')
-                               if known_targets_aliases.include?(parts[0])
-                                 [ parts[0], parts[1..-1].join(".") ]
-                               else
-                                 [ default_target, @children[0].name ]
-                               end
-                             else
-                               [default_target,@children[0].name]
-                             end
-          children_list = self.listup('EVENT_PROP_EXPR').map{|c| c.fields(default_target, known_targets_aliases)}.reduce(&:+) || []
+          parts = identifier.listup('escapableStr').map{|node| node.child.name }
+          target, fieldname = if parts.size == 1
+                                [ default_target, parts.first ]
+                              elsif known_targets_aliases.include?( parts.first )
+                                [ parts[0], parts[1..-1].join(".") ]
+                              else
+                                [ default_target, parts.join(".") ]
+                              end
+          children_list = self.listup(:prop).map{|c| c.fields(default_target, known_targets_aliases)}.reduce(&:+) || []
           [{:f => fieldname, :t => target}] + children_list
         end
       end
     end
 
-    class ASTStreamNode < ASTNode # STREAM_EXPR
+    class ASTStreamNode < ASTNode # streamExpression, subSelectFilterExpr
       def self.generate(name, children, tree)
-        if children.first.name == 'EVENT_FILTER_EXPR'
+        if children.first.name == 'eventFilterExpression'
           ASTStreamEventNode.new(name, children, tree)
-        elsif children.first.name == 'PATTERN_INCL_EXPR'
+        elsif children.first.name == 'patternInclusionExpression'
           ASTStreamPatternNode.new(name, children, tree)
         else
           raise "unexpected stream node type! report to norikra developer!: #{children.map(&:name).join(',')}"
@@ -344,38 +1129,77 @@ module Norikra
       #####      [ stream_def ... ]
       #
       # single Event stream name ( ex: FROM events.win:time(...) AS e )
-      #
-      #  ["STREAM_EXPR",
-      #   ["EVENT_FILTER_EXPR", "FraudWarningEvent"],
-      #   ["VIEW_EXPR", "win", "keepall"],
+
+      # ["streamExpression",
+      #   ["eventFilterExpression",
+      #     ["classIdentifier", ["escapableStr", "TestTable"]]],
+      #   ".",
+      #   ["viewExpression",
+      #     "win",
+      #     ":",
+      #     "time_batch",
+      #     "(",
+      #     ["expressionWithTimeList",
+      #       ["expressionWithTimeInclLast",
+      #         ["expressionWithTime",
+      #           ["timePeriod",
+      #             ["secondPart", ["numberconstant", ["number", "10"]], "sec"]]]]],
+      #     ")"],
+      # "regularJoin",
+
+      # ["streamExpression",
+      #   ["eventFilterExpression",
+      #     ["classIdentifier", ["escapableStr", "FraudWarningEvent"]]],
+      #   ".",
+      #   ["viewExpression", "win", ":", "keepall", "(", ")"],
+      #   "AS",
       #   "fraud"],
-      #
-      #  ["STREAM_EXPR",
-      #   ["EVENT_FILTER_EXPR",
-      #    "PINChangeEvent",
-      #    [">", ["EVENT_PROP_EXPR", ["EVENT_PROP_SIMPLE", "size"]], "10"]],
-      #   ["VIEW_EXPR", "win", "time", ["TIME_PERIOD", ["SECOND_PART", "20"]]]],
+      # ["regularJoin",
+      #   ",",
+      #   ["streamExpression",
+      #     ["eventFilterExpression",
+      #       ["classIdentifier", ["escapableStr", "PINChangeEvent"]],
+      #       "(",
+      #       ["expressionList",
+      #         ["expression", EXPRESSION...]],
+      #       ")"],
+      #     ".",
+      #     ["viewExpression",
+      #       "win",
+      #       ":",
+      #       "time",
+      #       "(",
+      #       ["expressionWithTimeList",
+      #         ["expressionWithTimeInclLast",
+      #           ["expressionWithTime",
+      #             ["timePeriod",
+      #               ["secondPart", ["numberconstant", ["number", "20"]], "sec"]]]]],
+      #       ")"]]]],
 
-      NON_ALIAS_NODES = ['EVENT_FILTER_EXPR','VIEW_EXPR','unidirectional','retain-union','retain-intersection']
+      NON_ALIAS_NODES = ['eventFilterExpression','viewExpression','.','unidirectional','retain-union','retain-intersection']
 
       def targets
-        [self.find('EVENT_FILTER_EXPR').child.name]
+        [ self.find('eventFilterExpression').find('classIdentifier').find('escapableStr').child.name ]
       end
 
       def aliases
         alias_nodes = children.select{|n| not NON_ALIAS_NODES.include?(n.name) }
-        if alias_nodes.size < 1
+        if alias_nodes.size == 2
+          if alias_nodes[0].name =~ /^as$/i
+            [ [ alias_nodes[1].name, self.targets.first ] ]
+          else
+            raise "unexpected FROM clause (non-AS for alias pattern): #{alias_nodes.map(&:name).join(',')}"
+          end
+        elsif alias_nodes.size == 0
           []
-        elsif alias_nodes.size > 1
-          raise "unexpected FROM clause (includes 2 or more alias words): #{alias_nodes.map(&:name).join(',')}"
-        else
-          [ [ alias_nodes.first.name, self.targets.first ] ]
+        else # 1 or 3 or more
+          raise "unexpected FROM clause (non-AS for alias pattern): #{alias_nodes.map(&:name).join(',')}"
         end
       end
 
       def fields(default_target=nil, known_targets_aliases=[])
         this_target = self.targets.first
-        self.listup('EVENT_PROP_EXPR').map{|p| p.fields(this_target,known_targets_aliases)}.reduce(&:+) || []
+        self.listup(:prop).map{|p| p.fields(this_target, known_targets_aliases)}.reduce(&:+) || []
       end
     end
 
@@ -385,28 +1209,48 @@ module Norikra
       #
       # pattern ( ex: FROM pattern[ every a=events1 -> b=Events1(name=a.name, type='T') where timer:within(1 min) ].win:time(2 hour) )
       #
-      # ["STREAM_EXPR",
-      #   ["PATTERN_INCL_EXPR",
-      #     ["FOLLOWED_BY_EXPR",
-      #       ["FOLLOWED_BY_ITEM", ["every", ["PATTERN_FILTER_EXPR", "a", "EventA"]]],
-      #       ["FOLLOWED_BY_ITEM",
-      #         ["GUARD_EXPR",
-      #           ["PATTERN_FILTER_EXPR",
-      #             "b",
-      #             "EventA",
-      #             ["EVAL_EQUALS_EXPR",
-      #               ["EVENT_PROP_EXPR", ["EVENT_PROP_SIMPLE", "name"]],
-      #               ["EVENT_PROP_EXPR",
-      #                 ["EVENT_PROP_SIMPLE", "a"],
-      #                 ["EVENT_PROP_SIMPLE", "name"]]],
-      #             ["EVAL_EQUALS_EXPR",
-      #               ["EVENT_PROP_EXPR", ["EVENT_PROP_SIMPLE", "type"]],
-      #               "'TYPE'"]],
-      #           "timer",
-      #           "within",
-      #           ["TIME_PERIOD", ["MINUTE_PART", "1"]]]]]],
-      #   ["VIEW_EXPR", "win", "time", ["TIME_PERIOD", ["HOUR_PART", "2"]]]],
-
+      #
+      # ["streamExpression",
+      #   ["patternInclusionExpression",
+      #     "pattern",
+      #     "[",
+      #     ["patternExpression",
+      #       ["followedByExpression",
+      #         ["orExpression", ["andExpression",
+      #             ["matchUntilExpression", ["qualifyExpression",
+      #                 "every",
+      #                 ["guardPostFix",
+      #                   ["atomicExpression",
+      #                     ["patternFilterExpression", "a", "=", ["classIdentifier", ["escapableStr", "EventA"]]]]]]]]],
+      #         ["followedByRepeat",
+      #           "->",
+      #           ["orExpression", ["andExpression",
+      #               ["matchUntilExpression", ["qualifyExpression",
+      #                   ["guardPostFix",
+      #                     ["atomicExpression",
+      #                       ["patternFilterExpression", "b", "=", ["classIdentifier", ["escapableStr", "EventA"]],
+      #                         "(",
+      #                         ["expressionList", ["expression", EXPRESSION...], ",", ["expression", EXPRESSION...]],
+      #                         ")"],
+      #                       "WHERE",
+      #                       ["guardWhereExpression",
+      #                         "timer",
+      #                         ":",
+      #                         "within",
+      #                         "(",
+      #                         ["expressionWithTimeList", ["expressionWithTimeInclLast", ["expressionWithTime",
+      #                               ["timePeriod", ["minutePart", ["numberconstant", ["number", "1"]], "min"]]]]],
+      #                         ")"]]]]]]]]],
+      #       "]"]],
+      #   ".",
+      #   ["viewExpression",
+      #     "win",
+      #     ":",
+      #     "time",
+      #     "(",
+      #     ["expressionWithTimeList", ["expressionWithTimeInclLast", ["expressionWithTime",
+      #           ["timePeriod", ["hourPart", ["numberconstant", ["number", "2"]], "hour"]]]]],
+      #     ")"]],
       def targets
         self.listup(:pattern).map(&:target)
       end
@@ -421,39 +1265,78 @@ module Norikra
     end
 
     class ASTPatternNode < ASTNode
-      # ["PATTERN_FILTER_EXPR", "a", "EventA"]
-      #
-      # ["PATTERN_FILTER_EXPR",
-      #   "b",
-      #   "EventA",
-      #   ["EVAL_EQUALS_EXPR",
-      #     ["EVENT_PROP_EXPR", ["EVENT_PROP_SIMPLE", "name"]],
-      #     ["EVENT_PROP_EXPR",
-      #       ["EVENT_PROP_SIMPLE", "a"],
-      #       ["EVENT_PROP_SIMPLE", "name"]]],
-      #   ["EVAL_EQUALS_EXPR",
-      #     ["EVENT_PROP_EXPR", ["EVENT_PROP_SIMPLE", "type"]],
-      #     "'TYPE'"]],
+      # ["patternFilterExpression", "a", "=", ["classIdentifier", ["escapableStr", "EventA"]]]
+
+      # ["patternFilterExpression", "b", "=", ["classIdentifier", ["escapableStr", "EventA"]],
+      #   "(",
+      #   ["expressionList", ["expression", EXPRESSION...], ",", ["expression", EXPRESSION...]],
+      #   ")"]
 
       def nodetype?(*sym)
         sym.include?(:pattern)
       end
 
       def target
-        children[1].name
+        self.find('classIdentifier').find('escapableStr').child.name
       end
 
       def alias
-        children[0].name
+        @children[0].name
       end
 
       def fields(default_target=nil, known_targets_aliases=[])
         this_target = self.target
-        self.listup('EVENT_PROP_EXPR').map{|p| p.fields(this_target, known_targets_aliases) }.reduce(&:+) || []
+        self.listup(:prop).map{|p| p.fields(this_target, known_targets_aliases) }.reduce(&:+) || []
       end
     end
 
-    class ASTSubSelectNode < ASTNode # SUBSELECT_EXPR
+    class ASTSubSelectNode < ASTNode
+      # ["startEPLExpressionRule",
+      #   ["eplExpression",
+      #     ["selectExpr",
+      #       "select",
+      #       ["selectClause", ["selectionList", ["selectionListElement", "*"]]],
+      #       "from",
+      #       ["fromClause",
+      #         ["streamExpression", ["eventFilterExpression", ["classIdentifier", ["escapableStr", "RfidEvent"]]], "as", "RFID"],
+      #         "regularJoin"],
+      #       "where",
+      #       ["whereClause",
+      #         ["evalOrExpression", ["evalAndExpression", ["bitWiseExpression", ["negatedExpression",
+      #                 ["evalEqualsExpression", ["evalRelationalExpression", ["concatenationExpr", ["additiveExpression",
+      #                         ["multiplyExpression", ["unaryExpression",
+      #                             ["constant", ["stringconstant", "\"Dock 1\""]]]]]]],
+      #                   "=",
+      #                   ["evalRelationalExpression",
+      #                     ["concatenationExpr", ["additiveExpression", ["multiplyExpression", ["unaryExpression",
+      #                             ["rowSubSelectExpression",
+      #                               ["subQueryExpr",
+      #                                 "(",
+      #                                 "select",
+      #                                 ["selectionList",
+      #                                   ["selectionListElement",
+      #                                     ["selectionListElementExpr",
+      #                                       ["expression", EXPRESSION...]]]],
+      #                                 "from",
+      #                                 ["subSelectFilterExpr",
+      #                                   ["eventFilterExpression", ["classIdentifier", ["escapableStr", "Zones"]]],
+      #                                   ".",
+      #                                   ["viewExpression",
+      #                                     "std",
+      #                                     ":",
+      #                                     "unique",
+      #                                     "(",
+      #                                     ["expressionWithTimeList",
+      #                                       ["expressionWithTimeInclLast",
+      #                                         ["expressionWithTime",
+      #                                           ["expressionQualifyable",
+      #                                             ["expression", EXPRESSION...]]]]],
+      #                                     ")"]],
+      #                                 "where",
+      #                                 ["whereClause", ...],
+      #                                 ")"]]]]]]]]]]]]]]],
+      #   "<EOF>"]
+
       def nodetype?(*sym)
         sym.include?(:subquery)
       end