norikra 1.1.2-java → 1.2.0-java

data/lib/norikra/query/ast.rb

@@ -717,6 +717,125 @@ module Norikra
     #                     ")"]]]]]]]]],
     #   "<EOF>"]
 
+    #### SELECT a,NULLABLE(b),COUNT(DISTINCT NULLABLE(c)) FROM t GROUP BY a,NULLABLE(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"]]]]]]]]]]]]]]]]]]],
+    #           ",",
+    #           ["selectionListElement",
+    #             ["selectionListElementExpr",
+    #               ["expression",
+    #                 ["caseExpression",["evalOrExpression",["evalAndExpression",["bitWiseExpression",["negatedExpression",
+    #                   ["evalEqualsExpression",["evalRelationalExpression",["concatenationExpr",["additiveExpression",
+    #                     ["multiplyExpression",["unaryExpression",
+    #                       ["eventPropertyOrLibFunction",
+    #                         ["libFunction",
+    #                           ["libFunctionWithClass",
+    #                             ["funcIdentTop", ["escapableIdent", "NULLABLE"]],
+    #                               "(",
+    #                               ["libFunctionArgs",
+    #                                 ["libFunctionArgItem",
+    #                                   ["expressionWithTime",
+    #                                     ["expressionQualifyable",
+    #                                       ["expression",
+    #                                         ["caseExpression",["evalOrExpression",["evalAndExpression",["bitWiseExpression",
+    #                                           ["negatedExpression",["evalEqualsExpression",["evalRelationalExpression",
+    #                                             ["concatenationExpr",["additiveExpression",["multiplyExpression",["unaryExpression",
+    #                                               ["eventPropertyOrLibFunction",
+    #                                                 ["eventProperty",
+    #                                                   ["eventPropertyAtomic",
+    #                                                     ["eventPropertyIdent", ["keywordAllowedIdent", "b"]]]]]]]]]]]]]]]]]]]]],
+    #                               ")"]]]]]]]]]]]]]]]]],
+    #           ",",
+    #           ["selectionListElement",
+    #             ["selectionListElementExpr",
+    #               ["expression",
+    #                 ["caseExpression",["evalOrExpression",["evalAndExpression",["bitWiseExpression",["negatedExpression",
+    #                   ["evalEqualsExpression",["evalRelationalExpression",["concatenationExpr",["additiveExpression",
+    #                     ["multiplyExpression",["unaryExpression",
+    #                       ["builtinFunc",
+    #                         "COUNT",
+    #                         "(",
+    #                         "DISTINCT",
+    #                         ["expression",
+    #                           ["caseExpression",["evalOrExpression",["evalAndExpression",["bitWiseExpression",
+    #                             ["negatedExpression",["evalEqualsExpression",["evalRelationalExpression",
+    #                               ["concatenationExpr",["additiveExpression",["multiplyExpression",["unaryExpression",
+    #                                 ["eventPropertyOrLibFunction",
+    #                                   ["libFunction",
+    #                                     ["libFunctionWithClass",
+    #                                       ["funcIdentTop", ["escapableIdent", "NULLABLE"]],
+    #                                         "(",
+    #                                         ["libFunctionArgs",
+    #                                           ["libFunctionArgItem",
+    #                                             ["expressionWithTime",
+    #                                               ["expressionQualifyable",
+    #                                                 ["expression",
+    #                                                   ["caseExpression",["evalOrExpression",["evalAndExpression",["bitWiseExpression",
+    #                                                     ["negatedExpression",["evalEqualsExpression",["evalRelationalExpression",
+    #                                                       ["concatenationExpr",["additiveExpression",["multiplyExpression",
+    #                                                         ["unaryExpression",
+    #                                                           ["eventPropertyOrLibFunction",
+    #                                                             ["eventProperty",
+    #                                                               ["eventPropertyAtomic",
+    #                                                                 ["eventPropertyIdent",
+    #                                                                   ["keywordAllowedIdent", "c"]]]]]]]]]]]]]]]]]]]]],
+    #                                                                       ")"]]]]]]]]]]]]]]],
+    #                                         ")"]]]]]]]]]]]]]]]]],
+    #       "FROM",
+    #       ["fromClause",
+    #         ["streamExpression", ["eventFilterExpression", ["classIdentifier", ["escapableStr", "t"]]]],
+    #         "regularJoin"],
+    #       "GROUP",
+    #       "BY",
+    #       ["groupByListExpr",
+    #         ["groupByListChoice",
+    #           ["expression",
+    #             ["caseExpression",["evalOrExpression",["evalAndExpression",["bitWiseExpression",["negatedExpression",
+    #               ["evalEqualsExpression",["evalRelationalExpression",["concatenationExpr",["additiveExpression",
+    #                 ["multiplyExpression",["unaryExpression",
+    #                   ["eventPropertyOrLibFunction",
+    #                     ["eventProperty",
+    #                       ["eventPropertyAtomic", ["eventPropertyIdent", ["keywordAllowedIdent", "a"]]]]]]]]]]]]]]]]]],
+    #         ",",
+    #         ["groupByListChoice",
+    #           ["expression",
+    #             ["caseExpression",["evalOrExpression",["evalAndExpression",["bitWiseExpression",["negatedExpression",
+    #               ["evalEqualsExpression",["evalRelationalExpression",["concatenationExpr",["additiveExpression",
+    #                 ["multiplyExpression",["unaryExpression",
+    #                   ["eventPropertyOrLibFunction",
+    #                     ["libFunction",
+    #                       ["libFunctionWithClass",
+    #                         ["funcIdentTop", ["escapableIdent", "NULLABLE"]],
+    #                         "(",
+    #                         ["libFunctionArgs",
+    #                           ["libFunctionArgItem",
+    #                             ["expressionWithTime",
+    #                               ["expressionQualifyable",
+    #                                 ["expression",
+    #                                   ["caseExpression",["evalOrExpression",["evalAndExpression",["bitWiseExpression",
+    #                                     ["negatedExpression",["evalEqualsExpression",["evalRelationalExpression",
+    #                                       ["concatenationExpr",["additiveExpression",["multiplyExpression",["unaryExpression",
+    #                                         ["eventPropertyOrLibFunction",
+    #                                           ["eventProperty",
+    #                                             ["eventPropertyAtomic",
+    #                                               ["eventPropertyIdent", ["keywordAllowedIdent", "b"]]]]]]]]]]]]]]]]]]]]],
+    #                                         ")"]]]]]]]]]]]]]]]]]]],
+    #   "<EOF>"]
+
     def astnode(tree)
       # com.espertech.esper.epl.generated.EsperEPL2GrammarParser.ruleNames[ast.ruleIndex] #=> "startEPLExpressionRule"
       # com.espertech.esper.epl.generated.EsperEPL2GrammarParser.ruleNames[ast.getChild(0).ruleIndex] #=> "eplExpression"
@@ -745,9 +864,11 @@ module Norikra
       end
 
       cls = case name
+            when 'expression' then ASTExpression
             when 'eventProperty' then ASTEventPropNode
             when 'selectionListElementExpr' then ASTSelectionElementNode
             when 'libFunction' then ASTLibFunctionNode
+            when 'libFunctionArgItem' then ASTLibFunctionArgItemNode
             when 'streamExpression', 'subSelectFilterExpr' then ASTStreamNode
             when 'patternFilterExpression' then ASTPatternNode
             when 'subQueryExpr' then ASTSubSelectNode
@@ -769,6 +890,14 @@ module Norikra
         @tree = tree
       end
 
+      def has_a?(name)
+        @children.size == 1 && (@children.first.name == name || @children.first.nodetype?(name))
+      end
+
+      def chain(*nodes)
+        nodes.reduce(self){|n, next_node| n && n.has_a?(next_node) ? n.child : nil }
+      end
+
       def nodetype?(*sym)
         false
       end
@@ -813,6 +942,28 @@ module Norikra
       end
     end
 
+    class ASTExpression < ASTNode
+      # ["expression",
+      #   ["caseExpression", ["evalOrExpression", ["evalAndExpression", ["bitWiseExpression", ["negatedExpression",
+      #     ["evalEqualsExpression", ["evalRelationalExpression", ["concatenationExpr", ["additiveExpression",
+      #       ["multiplyExpression", ["unaryExpression", ["eventPropertyOrLibFunction",
+      #         ["eventProperty",
+      #           ["eventPropertyAtomic", ["eventPropertyIdent", ["keywordAllowedIdent", "s"]]]]]]]]]]]]]]]]]]]
+      def nodetype?(*sym)
+        sym.include?(:expression)
+      end
+
+      SIMPLE_PROPERTY_REFERENCE_NODES = [
+        "caseExpression", "evalOrExpression", "evalAndExpression", "bitWiseExpression", "negatedExpression",
+        "evalEqualsExpression", "evalRelationalExpression", "concatenationExpr", "additiveExpression",
+        "multiplyExpression", "unaryExpression", "eventPropertyOrLibFunction", "eventProperty"
+      ]
+      def propertyReference?
+        end_node = self.chain(*SIMPLE_PROPERTY_REFERENCE_NODES)
+        end_node && end_node.nodetype?(:property)
+      end
+    end
+
     class ASTEventPropNode < ASTNode # eventProperty
       ### "a"
       # ["eventProperty", ["eventPropertyAtomic", ["eventPropertyIdent", ["keywordAllowedIdent", "a"]]]
@@ -870,13 +1021,13 @@ module Norikra
         if props.size > 1 # alias.fieldname or container_fieldname.key.$1 or fieldname.method(...)
           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} ]
+            [ {f: non_calls[1..-1].join("."), t: leading_name} ]
           else
-            [ {:f => non_calls.join("."), :t => default_target} ]
+            [ {f: non_calls.join("."), t: default_target} ]
           end
         else # fieldname (default target)
           # ["eventProperty", ["eventPropertyAtomic", ["eventPropertyIdent", ["keywordAllowedIdent", "a"]]]
-          [ {:f => leading_name, :t => default_target } ]
+          [ {f: leading_name, t: default_target } ]
         end
       end
     end
@@ -892,7 +1043,7 @@ module Norikra
       #             ["eventProperty",
       #               ["eventPropertyAtomic", ["eventPropertyIdent", ["keywordAllowedIdent", "s"]]]]]]]]]]]]]]]]]]]
 
-      ### "count(*) AS cnt"  => ["SELECTION_ELEMENT_EXPR", "count", "cnt"]
+      ### "count(*) AS cnt"
       # ["selectionListElementExpr",
       #   ["expression",
       #     ["caseExpression", ["evalOrExpression", ["evalAndExpression", ["bitWiseExpression", ["negatedExpression",
@@ -925,6 +1076,22 @@ module Norikra
     end
 
     class ASTLibFunctionNode < ASTNode # LIB_FUNCTION
+      ### NULLABLE field!
+      # ["libFunction",
+      #   ["libFunctionWithClass",
+      #     ["funcIdentTop", ["escapableIdent", "NULLABLE"]],
+      #     "(",
+      #     ["libFunctionArgs",["libFunctionArgItem",["expressionWithTime",["expressionQualifyable",
+      #       ["expression",
+      #         ["caseExpression",["evalOrExpression",["evalAndExpression",["bitWiseExpression",["negatedExpression",
+      #           ["evalEqualsExpression",["evalRelationalExpression",["concatenationExpr",["additiveExpression",
+      #             ["multiplyExpression",["unaryExpression",
+      #               ["eventPropertyOrLibFunction",
+      #                 ["eventProperty",
+      #                   ["eventPropertyAtomic",
+      #                     ["eventPropertyIdent", ["keywordAllowedIdent", "b"]]]]]]]]]]]]]]]]]]]]],
+      #     ")"]]]
+
       ### foo is function
       # "foo()"     => ["libFunction", ["libFunctionWithClass", ["funcIdentTop", ["escapableIdent", "foo"]], "(", ")"]]
 
@@ -948,6 +1115,25 @@ module Norikra
       #       ["libFunctionArgItem", ["expressionWithTime", ["expressionQualifyable", ["expression", EXPRESSION... ]]]]],
       #     ")"]]
 
+      ### foo(value)
+      # ["libFunction",
+      #   ["libFunctionWithClass",
+      #     ["funcIdentTop", ["escapableIdent", "FOO"]],
+      #     "(",
+      #     ["libFunctionArgs",
+      #       ["libFunctionArgItem",
+      #         ["expressionWithTime",
+      #           ["expressionQualifyable",
+      #             ["expression",
+      #               ["caseExpression",["evalOrExpression",["evalAndExpression",["bitWiseExpression",["negatedExpression",
+      #                 ["evalEqualsExpression",["evalRelationalExpression",["concatenationExpr",["additiveExpression",
+      #                   ["multiplyExpression",["unaryExpression",
+      #                     ["eventPropertyOrLibFunction",
+      #                       ["eventProperty",
+      #                         ["eventPropertyAtomic",
+      #                           ["eventPropertyIdent", ["keywordAllowedIdent", "value"]]]]]]]]]]]]]]]]]]]]],
+      #     ")"]]
+
       ### foo is property
       ### "foo.bar()"
       # ["libFunction",
@@ -1067,33 +1253,67 @@ module Norikra
       #     "(",
       #     ")"]]
 
+      def function_name
+        f = self.find("funcIdentTop")
+        if e = f.find("escapableIdent")
+          e.child.name
+        else
+          f.child.name
+        end
+      end
+
       def nodetype?(*sym)
         sym.include?(:lib) || sym.include?(:libfunc)
       end
 
       def fields(default_target=nil, known_targets_aliases=[])
+        # class identifier is receiver: "IDENT.func()"
         identifier = self.find("classIdentifier")
-
-        return [] if identifier.nil? # built-in function call (no receivers exists)
-
-        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(:prop).map{|c| c.fields(default_target, known_targets_aliases)}.reduce(&:+) || []
+        if identifier
+          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(:prop).map{|c| c.fields(default_target, known_targets_aliases)}.reduce(&:+) || []
+          else
+            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
         else
-          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
+          if self.function_name.upcase == 'NULLABLE'
+            props = self.listup(:prop).map{|c| c.fields(default_target, known_targets_aliases)}.reduce(&:+) || []
+            props.each do |def_item|
+              def_item[:n] = true # nullable: true
+            end
+            props
+          else
+            self.listup(:prop).map{|c| c.fields(default_target, known_targets_aliases)}.reduce(&:+) || []
+          end
         end
       end
     end
 
+    class ASTLibFunctionArgItemNode < ASTNode
+      # ["libFunctionArgs",
+      #   ["libFunctionArgItem",
+      #     ["expressionWithTime",
+      #       ["expressionQualifyable",
+      #         ["expression", ... ]]]]
+      def nodetype?(*sym)
+        sym.include?(:libarg)
+      end
+
+      def expression
+        self.chain("expressionWithTime", "expressionQualifyable", "expression")
+      end
+    end
+
     class ASTStreamNode < ASTNode # streamExpression, subSelectFilterExpr
       def self.generate(name, children, tree)
         if children.first.name == 'eventFilterExpression'

data/lib/norikra/query.rb

@@ -27,6 +27,12 @@ module Norikra
       @aliases = nil
       @subqueries = nil
       @fields = nil
+      @nullable_fields = nil
+    end
+
+    def inspect
+      internal = ['name', 'group', 'expression', 'statement_name', 'targets', 'aliases', 'fields', 'nullable_fields', 'subqueries', 'fieldsets'].map{|x| "@#{x}=" + self.send(x.to_sym).inspect }.join(", ")
+      "<#Norikra::Query:#{self.object_id} #{internal}>"
     end
 
     def <=>(other)
@@ -45,16 +51,8 @@ module Norikra
       end
     end
 
-    def self.loopback(group)
-      group && group =~ /^LOOPBACK\((.+)\)$/ && $1
-    end
-
-    def self.stdout?(group)
-      group && group == "STDOUT()"
-    end
-
     def dup
-      self.class.new(:name => @name, :group => @group, :expression => @expression.dup)
+      self.class.new(name: @name, group: @group, expression: @expression.dup)
     end
 
     def to_hash
@@ -70,8 +68,26 @@ module Norikra
     end
 
     def invalid?
-      # check query is invalid as Norikra query or not
-      self.ast.listup('selectionListElement').any?{|node| node.children.map(&:name).any?{|name| name == '*' } }
+      # check query is invalid as Norikra query or not, and return invalid reason (or nil for valid queries)
+
+      # "SELECT *" is prohibited because each Norikra targets does not have all fields users expect
+      if self.ast.listup('selectionListElement').any?{|node| node.children.map(&:name).any?{|name| name == '*' } }
+        # '*' is a direct child of selectionListElement, not selectionListElementExpr
+        return "'SELECT *' is prohibited in query"
+      end
+
+      # NULLABLE(...) can have "a" single field reference only
+      nullables = self.ast.listup(:libfunc).select{|node| node.function_name.upcase == "NULLABLE" }
+      if nullables.size > 0
+        unless nullables.all?{|node| args = node.find("libFunctionArgs"); args && args.has_a?(:libarg) }
+          return "NULLABLE(...) must have a field argument"
+        end
+        unless nullables.all?{|node| exp = node.find(:libarg).expression; exp && exp.propertyReference? }
+          return "NULLABLE(...) can get a field, not expression"
+        end
+      end
+
+      nil
     end
 
     def targets
@@ -93,74 +109,85 @@ module Norikra
     end
 
     def explore(outer_targets=[], alias_overridden={})
-      fields = {}
-      alias_map = {}.merge(alias_overridden)
+      fields = {
+        defs: { all: [], unknown: [], target: {} },
+        nullables: { all: [], unknown: [], target: {} },
+      }
+
+      alias_map = alias_overridden.dup
 
-      all = []
-      unknowns = []
       self.ast.listup(:stream).each do |node|
         node.aliases.each do |alias_name, target|
           alias_map[alias_name] = target
         end
         node.targets.each do |target|
-          fields[target] ||= []
+          fields[:defs][:target][target] = []
+          fields[:nullables][:target][target] = []
         end
       end
 
-      dup_aliases = (alias_map.keys & fields.keys)
-      unless dup_aliases.empty?
-        raise Norikra::ClientError, "Invalid alias '#{dup_aliases.join(',')}', same with target name"
-      end
-
-      default_target = fields.keys.size == 1 ? fields.keys.first : nil
+      # default target should be out of effect of outer_targets
+      default_target = fields[:defs][:target].keys.size == 1 ? fields[:defs][:target].keys.first : nil
 
       outer_targets.each do |t|
-        fields[t] ||= []
+        fields[:defs][:target][t] ||= []
+        fields[:nullables][:target][t] ||= []
       end
 
-      field_bag = []
-      self.subqueries.each do |subquery|
-        field_bag.push(subquery.explore(fields.keys, alias_map))
+      dup_aliases = (alias_map.keys & fields[:defs][:target].keys)
+      unless dup_aliases.empty?
+        raise Norikra::ClientError, "Invalid alias '#{dup_aliases.join(',')}', same with target name"
       end
 
       # names of 'AS'
       field_aliases = self.ast.listup(:selection).map(&:alias).compact
 
-      known_targets_aliases = fields.keys + alias_map.keys
+      known_targets_aliases = fields[:defs][:target].keys + alias_map.keys
       self.ast.fields(default_target, known_targets_aliases).each do |field_def|
         f = field_def[:f]
         next if field_aliases.include?(f)
 
-        all.push(f)
+        fields[:defs][:all].push(f)
+        fields[:nullables][:all].push(f) if field_def[:n]
 
         if field_def[:t]
           t = alias_map[field_def[:t]] || field_def[:t]
-          unless fields[t]
+          unless fields[:defs][:target][t]
             raise Norikra::ClientError, "unknown target alias name for: #{field_def[:t]}.#{field_def[:f]}"
           end
-          fields[t].push(f)
-
+          fields[:defs][:target][t].push(f)
+          fields[:nullables][:target][t].push(f) if field_def[:n]
         else
-          unknowns.push(f)
+          fields[:defs][:unknown].push(f)
+          fields[:nullables][:unknown].push(f) if field_def[:n]
         end
       end
 
-      field_bag.each do |bag|
-        all += bag['']
-        unknowns += bag[nil]
-        bag.keys.each do |t|
-          fields[t] ||= []
-          fields[t] += bag[t]
+      self.subqueries.each do |subquery|
+        sub = {}
+        sub[:defs], sub[:nullables] = subquery.explore(fields[:defs][:target].keys, alias_map)
+
+        [:defs, :nullables].each do |group|
+          fields[group][:all] += sub[group].delete('')
+          fields[group][:unknown] += sub[group].delete(nil)
+          sub[group].keys.each do |t|
+            fields[group][:target][t] ||= []
+            fields[group][:target][t] += sub[group][t]
+          end
         end
       end
 
-      fields.keys.each do |target|
-        fields[target] = fields[target].sort.uniq
-      end
-      fields[''] = all.sort.uniq
-      fields[nil] = unknowns.sort.uniq
+      compact = ->(data){
+        r = {}
+        data[:target].keys.each do |t|
+          r[t] = data[:target][t].sort.uniq
+        end
+        r[''] = data[:all].sort.uniq
+        r[nil] = data[:unknown].sort.uniq
+        r
+      }
 
-      fields
+      [ compact.(fields[:defs]), compact.(fields[:nullables]) ]
     end
 
     def fields(target='')
@@ -168,10 +195,18 @@ module Norikra
       # target nil: fields for unknown targets
       return @fields[target] if @fields
 
-      @fields = explore()
+      @fields, @nullable_fields = explore()
       @fields[target]
     end
 
+    def nullable_fields(target='')
+      # argument target is same with #fields
+      return @nullable_fields[target] if @nullable_fields
+
+      @fields, @nullable_fields = explore()
+      @nullable_fields[target]
+    end
+
     class ParseRuleSelectorImpl
       include Java::ComEspertechEsperEplParse::ParseRuleSelector
       def invokeParseRule(parser)
@@ -218,10 +253,32 @@ module Norikra
     end
 
     def self.rewrite_query(statement_model, mapping)
+      rewrite_nullable_fields(statement_model)
       rewrite_event_type_name(statement_model, mapping)
       rewrite_event_field_name(statement_model, mapping)
     end
 
+    def self.rewrite_nullable_fields(statement_model)
+      # NULLABLE(field) -> field
+      ## NOTICE: NULLABLE(...) cannot be used in view parameters. ex: target.std:unique(NULLABLE(a)) -> x
+      rewriter = lambda {|node|
+        if node.respond_to?(:getExpression)
+          exp = node.getExpression
+          if exp && exp.is_a?(Java::ComEspertechEsperClientSoda::DotExpression) && exp.getChain.size == 1
+            # top-level lib function
+            # exp.getChain[0] #=> Java::ComEspertechEsperClientSoda::DotExpressionItem
+            if exp.getChain[0].name.upcase == 'NULLABLE'
+              node.setExpression(exp.getChain[0].getParameters[0])
+            end
+          end
+        end
+      }
+      recaller = lambda {|node|
+        Norikra::Query.rewrite_nullable_fields(node.getModel)
+      }
+      traverse_fields(rewriter, recaller, statement_model)
+    end
+
     def self.rewrite_event_field_name(statement_model, mapping)
       # mapping: {target_name => query_event_type_name}
       #  mapping is for target name rewriting of fully qualified field name access
@@ -235,7 +292,7 @@ module Norikra
       # model.getWhereClause.getChildren[1].getChildren[0].getPropertyName #=> 'field.key1.$1'
       # model.getWhereClause.getChildren[2].getChildren[0].getChain[0].getName #=> 'opts.num.$0' from opts.num.$0.length()
 
-      query = Norikra::Query.new(:name => 'dummy name by .rewrite_event_field_name', :expression => statement_model.toEPL)
+      query = Norikra::Query.new(name: 'dummy name by .rewrite_event_field_name', expression: statement_model.toEPL)
       targets = query.targets
       fqfs_prefixes = targets + query.aliases
 

data/lib/norikra/rpc/handler.rb

@@ -13,9 +13,9 @@ class Norikra::RPC::Handler
 
   def logging(type, handler, args=[])
     if type == :manage
-      debug "RPC", :handler => handler.to_s, :args => args
+      debug("RPC"){ { handler: handler.to_s, args: args } }
     else
-      trace "RPC", :handler => handler.to_s, :args => args
+      trace("RPC"){ { handler: handler.to_s, args: args } }
     end
 
     begin
@@ -67,7 +67,7 @@ class Norikra::RPC::Handler
 
   def register(query_name, query_group, expression)
     logging(:manage, :register, [query_name, query_group, expression]){
-      r = @engine.register(Norikra::Query.new(:name => query_name, :group => query_group, :expression => expression))
+      r = @engine.register(Norikra::Query.new(name: query_name, group: query_group, expression: expression))
       !!r
     }
   end

data/lib/norikra/rpc/http.rb

@@ -35,7 +35,7 @@ module Norikra::RPC
       info "RPC server #{@host}:#{@port}, #{@threads} threads"
       @thread = Thread.new do
         @mizuno = Mizuno::Server.new
-        @mizuno.run(@app, :embedded => true, :threads => @threads, :port => @port, :host => @host)
+        @mizuno.run(@app, embedded: true, threads: @threads, port: @port, host: @host)
       end
     end