norikra 0.0.13-java → 0.0.14-java

data/lib/norikra/typedef_manager.rb

@@ -13,7 +13,8 @@ module Norikra
     end
 
     def field_list(target)
-      @typedefs[target].fields.values.sort{|a,b| a.name <=> b.name}.map(&:to_hash)
+      @typedefs[target].dump.map{|key,hash_value| hash_value}
+      # @typedefs[target].fields.values.sort{|a,b| a.name <=> b.name}.map(&:to_hash)
     end
 
     def add_target(target, fields)
@@ -45,15 +46,26 @@ module Norikra
       @typedefs[target].reserve(field, type)
     end
 
-    def fields_defined?(target, field_name_list)
-      @typedefs[target].field_defined?(field_name_list)
-    end
-
     def ready?(query)
       query.targets.all?{|t| @typedefs[t] && ! @typedefs[t].lazy? && @typedefs[t].field_defined?(query.fields(t))} &&
         query.fields(nil).all?{|f| query.targets.any?{|t| @typedefs[t].field_defined?([f])}}
     end
 
+    def register_waiting_fields(query)
+      query.targets.each do |t|
+        next if t.nil?
+
+        typedef = @typedefs[t]
+        fields = typedef.fields
+
+        query.fields(t).each do |fieldname|
+          if !fields.has_key?(fieldname) && !typedef.waiting_fields.include?(fieldname)
+            typedef.waiting_fields.push(fieldname)
+          end
+        end
+      end
+    end
+
     def generate_fieldset_mapping(query)
       fields_set = {}
 
@@ -89,7 +101,7 @@ module Norikra
     end
 
     def generate_base_fieldset(target, event)
-      guessed = Norikra::FieldSet.simple_guess(event, false) # all fields are non-optional
+      guessed = @typedefs[target].simple_guess(event, false, false) # all fields are non-optional
       guessed.update(@typedefs[target].fields, false)
       guessed
     end
@@ -133,18 +145,12 @@ module Norikra
       sets
     end
 
-    def refer(target, event)
-      @typedefs[target].refer(event)
-    end
-
-    def format(target, event)
-      @typedefs[target].format(event)
+    def refer(target_name, event, strict=false)
+      @typedefs[target_name].refer(event, strict)
     end
 
-    def dump
-      @typedefs.keys.map{|target|
-        {:name => target, :fields => @typedefs[target].dump}
-      }
+    def dump_target(name)
+      @typedefs[name].dump_all
     end
   end
 end

data/lib/norikra/version.rb

@@ -1,3 +1,3 @@
 module Norikra
-  VERSION = "0.0.13"
+  VERSION = "0.0.14"
 end

data/norikra.gemspec

@@ -23,7 +23,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "rack"
   spec.add_runtime_dependency "msgpack-rpc-over-http-jruby", ">= 0.0.5"
   spec.add_runtime_dependency "thor"
-  spec.add_runtime_dependency "norikra-client-jruby", ">= 0.0.6"
+  spec.add_runtime_dependency "norikra-client-jruby", ">= 0.0.7"
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"

data/script/spec_server_pry

@@ -22,6 +22,37 @@ def rspec(file=nil)
   end
 end
 
+$service = nil
+def service
+  $service ||= com.espertech.esper.client.EPServiceProviderManager.getDefaultProvider
+end
+
+$administrator = nil
+def administrator
+  $administrator ||= service.getEPAdministrator
+end
+
+def compileEPL(query_str)
+  administrator.compileEPL(query_str)
+end
+
+def query_string(model)
+  writer = java.io.StringWriter.new
+  formatter = com.espertech.esper.client.soda.EPStatementFormatter.new
+  if model.respond_to?(:toEPLElement)
+    model.toEPLElement(writer)
+    writer.toString
+  elsif model.respond_to?(:toPrecedenceFreeEPL)
+    model.toPrecedenceFreeEPL(writer)
+    writer.toString
+  elsif model.is_a?(Java::ComEspertechEsperClientSoda::EPStatementObjectModel)
+    model.toEPL
+  else
+    model.toEPL(writer, formatter)
+    writer.toString
+  end
+end
+
 puts <<DESC
 
 Example:

data/spec/field_spec.rb

@@ -1,12 +1,73 @@
+# -*- coding: utf-8 -*-
 require_relative './spec_helper'
 
-require 'norikra/typedef'
-# require 'norikra/error'
+require 'norikra/field'
 
 require 'json'
 require 'digest'
 
 describe Norikra::Field do
+  describe '.escape_name' do
+    it 'escapes chars not alphabetic and numeric chars, with "_"' do
+      expect(Norikra::Field.escape_name("part1 part2")).to eql('part1_part2')
+      expect(Norikra::Field.escape_name("part1^part2")).to eql('part1_part2')
+      expect(Norikra::Field.escape_name("part1|part2")).to eql('part1_part2')
+      expect(Norikra::Field.escape_name("part1\"part2")).to eql('part1_part2')
+      expect(Norikra::Field.escape_name("part1'part2")).to eql('part1_part2')
+      expect(Norikra::Field.escape_name("part1@part2")).to eql('part1_part2')
+      expect(Norikra::Field.escape_name("part1#part2")).to eql('part1_part2')
+      expect(Norikra::Field.escape_name("part1あpart2")).to eql('part1_part2')
+    end
+
+    it 'escape "." in field name with "$"' do
+      expect(Norikra::Field.escape_name("part1.part2")).to eql('part1$part2')
+    end
+
+    it 'escape additional "." which specify string-dot of key chain escaped with "_"' do
+      expect(Norikra::Field.escape_name("part1..part2")).to eql('part1$_part2')
+    end
+
+    it 'escape numeric-only part with prefix "$"' do
+      expect(Norikra::Field.escape_name("part1.0")).to eql('part1$$0')
+    end
+  end
+
+  describe '.regulate_key_chain' do
+    it 'escape String chain items and returns by array which started with numeric, with "$$", and joins keys with separator "$"' do
+      expect(Norikra::Field.regulate_key_chain(["part1", "part2"])).to eql(['part1','part2'])
+      expect(Norikra::Field.regulate_key_chain(["part.1", "2"])).to eql(['part_1', '$$2'])
+      expect(Norikra::Field.regulate_key_chain(["part1", 2])).to eql(['part1', '$2'])
+      expect(Norikra::Field.regulate_key_chain(["part1", 2, "2"])).to eql(['part1', '$2', '$$2'])
+      expect(Norikra::Field.regulate_key_chain(["part1", ".part2"])).to eql(['part1', '_part2'])
+      expect(Norikra::Field.regulate_key_chain(["part1", 2, ".part2"])).to eql(['part1', '$2', '_part2'])
+    end
+  end
+
+  describe '.escape_key_chain' do
+    it 'escape String chain items which started with numeric, with "$$", and joins keys with separator "$"' do
+      expect(Norikra::Field.escape_key_chain("part1", "part2")).to eql('part1$part2')
+      expect(Norikra::Field.escape_key_chain("part.1", "2")).to eql('part_1$$$2')
+      expect(Norikra::Field.escape_key_chain("part1", 2)).to eql('part1$$2')
+      expect(Norikra::Field.escape_key_chain("part1", 2, "2")).to eql('part1$$2$$$2')
+      expect(Norikra::Field.escape_key_chain("part1", ".part2")).to eql('part1$_part2')
+      expect(Norikra::Field.escape_key_chain("part1", 2, ".part2")).to eql('part1$$2$_part2')
+    end
+  end
+
+  describe '.container_type?' do
+    it 'returns true for only "hash" and "array"' do
+      expect(Norikra::Field.container_type?('')).to be_false
+      expect(Norikra::Field.container_type?('string')).to be_false
+      expect(Norikra::Field.container_type?('int')).to be_false
+      expect(Norikra::Field.container_type?('long')).to be_false
+
+      expect(Norikra::Field.container_type?('Hash')).to be_true
+      expect(Norikra::Field.container_type?('hash')).to be_true
+      expect(Norikra::Field.container_type?('Array')).to be_true
+      expect(Norikra::Field.container_type?('array')).to be_true
+    end
+  end
+
   describe '.valid_type?' do
     it 'returns normalized type strings' do
       expect(Norikra::Field.valid_type?('String')).to eql('string')
@@ -139,4 +200,72 @@ describe Norikra::Field do
       end
     end
   end
+
+  describe '#define_value_accessor' do
+    it 'defines value accessor method for simple single field name' do
+      f = Norikra::Field.new('foo', 'string')
+
+      f.define_value_accessor('foo', false)
+      expect(f.value({'foo' => 'value1', 'bar' => 'value2', 'baz' => 'value3'})).to eql('value1')
+    end
+
+    it 'defines chain value accessor for 2-depth hash access chain' do
+      f = Norikra::Field.new('foo', 'hash')
+      f.define_value_accessor('foo.bar', true)
+      expect(f.value({'foo' => {'bar' => 'value1'}, 'bar' => 'value2'})).to eql('value1')
+      expect(f.value({'foo' => ['value1'], 'bar' => 'value2'})).to be_nil
+      expect(f.value({'foo' => 'value1', 'bar' => 'value2'})).to be_nil
+    end
+
+    it 'defines chain value accessor for 2-depth array access chain' do
+      f = Norikra::Field.new('foo', 'array')
+      f.define_value_accessor('foo.0', true)
+      expect(f.value({'foo' => {'bar' => 'value1'}, 'bar' => 'value2'})).to be_nil
+      expect(f.value({'foo' => ['value1'], 'bar' => 'value2'})).to eql('value1')
+      expect(f.value({'foo' => 'value1', 'bar' => 'value2'})).to be_nil
+    end
+
+    it 'defines chain value accessor for 2-depth array access chain' do
+      f = Norikra::Field.new('foo', 'array')
+      f.define_value_accessor('foo.$0', true)
+      expect(f.value({'foo' => {0 => 'value1'}, 'bar' => 'value2'})).to eql('value1')
+      expect(f.value({'foo' => {'bar' => 'value1'}, 'bar' => 'value2'})).to be_nil
+      expect(f.value({'foo' => ['value1'], 'bar' => 'value2'})).to eql('value1')
+      expect(f.value({'foo' => 'value1', 'bar' => 'value2'})).to be_nil
+    end
+
+    it 'defines chain value accessor for 2-depth hash access chain, with numeric string' do
+      f = Norikra::Field.new('foo', 'hash')
+      f.define_value_accessor('foo.$$0', true)
+      expect(f.value({'foo' => {0 => 'value1'}, 'bar' => 'value2'})).to be_nil
+      expect(f.value({'foo' => {'0' => 'value1'}, 'bar' => 'value2'})).to eql('value1')
+      expect(f.value({'foo' => ['value1'], 'bar' => 'value2'})).to be_nil
+      expect(f.value({'foo' => 'value1', 'bar' => 'value2'})).to be_nil
+    end
+
+    it 'defines chain value accessor for 2-depth access chain, with integer key' do
+      f = Norikra::Field.new('foo', 'hash')
+      f.define_value_accessor('foo.0', true)
+      expect(f.value({'foo' => {0 => 'value1'}, 'bar' => 'value2'})).to eql('value1')
+      expect(f.value({'foo' => {'0' => 'value1'}, 'bar' => 'value2'})).to eql('value1')
+      expect(f.value({'foo' => ['value1'], 'bar' => 'value2'})).to eql('value1')
+      expect(f.value({'foo' => 'value1', 'bar' => 'value2'})).to be_nil
+    end
+
+    it 'defines chain value accessor for 2-depth chain with dots' do
+      f = Norikra::Field.new('foo', 'hash')
+      f.define_value_accessor('foo..data', true)
+      expect(f.value({'foo' => {'.data' => 'value1'}, 'bar' => 'value2'})).to eql('value1')
+      expect(f.value({'foo' => ['value1'], 'bar' => 'value2'})).to be_nil
+      expect(f.value({'foo' => 'value1', 'bar' => 'value2'})).to be_nil
+    end
+
+    it 'defines chain value accessor for N-depth hash and array' do
+      f = Norikra::Field.new('foo', 'hash')
+      f.define_value_accessor('foo.bar.$0.baz', true)
+      expect(f.value({'foo' => {'bar' => [{'baz' => 'value1'}, {'baz' => 'value2'}]}})).to eql('value1')
+      f.define_value_accessor('foo.bar.1.baz', true)
+      expect(f.value({'foo' => {'bar' => [{'baz' => 'value1'}, {'baz' => 'value2'}]}})).to eql('value2')
+    end
+  end
 end

data/spec/fieldset_spec.rb

@@ -1,33 +1,11 @@
 require_relative './spec_helper'
 
-require 'norikra/typedef'
+require 'norikra/fieldset'
 
 require 'json'
 require 'digest'
 
 describe Norikra::FieldSet do
-  describe '.simple_guess' do
-    it 'can guess field definitions with class of values' do
-      t = Norikra::FieldSet.simple_guess({'key1' => true, 'key2' => false, 'key3' => 10, 'key4' => 3.1415, 'key5' => 'foobar'})
-      r = t.definition
-      expect(r['key1']).to eql('boolean')
-      expect(r['key2']).to eql('boolean')
-      expect(r['key3']).to eql('long')
-      expect(r['key4']).to eql('double')
-      expect(r['key5']).to eql('string')
-    end
-
-    it 'does not guess with content of string values' do
-      t = Norikra::FieldSet.simple_guess({'key1' => 'TRUE', 'key2' => 'false', 'key3' => "10", 'key4' => '3.1415', 'key5' => {:a => 1}})
-      r = t.definition
-      expect(r['key1']).to eql('string')
-      expect(r['key2']).to eql('string')
-      expect(r['key3']).to eql('string')
-      expect(r['key4']).to eql('string')
-      expect(r['key5']).to eql('string')
-    end
-  end
-
   describe 'can be initialized with both of Hash parameter and String' do
     it 'accepts String as type' do
       set = Norikra::FieldSet.new({'x' => 'string', 'y' => 'long'})
@@ -71,6 +49,40 @@ describe Norikra::FieldSet do
       end
     end
 
+    describe '.leaves' do
+      it 'returns field access chains to all keys of 1-depth Hash container' do
+        leaves = Norikra::FieldSet.leaves({'field1' => 1, 'field2' => 2})
+        expect(leaves.size).to eql(2)
+        expect(leaves).to eql([['field1', 1], ['field2', 2]])
+      end
+
+      it 'returns field access chains to all indexes of 1-depth Array container' do
+        leaves = Norikra::FieldSet.leaves([1, 2, 3])
+        expect(leaves.size).to eql(3)
+        expect(leaves).to eql([[0, 1], [1, 2], [2, 3]])
+      end
+
+      it 'returns field access chains of 2-depth array' do
+        leaves = Norikra::FieldSet.leaves([[0, 1, 2], 3, 4])
+        expect(leaves.size).to eql(5)
+        expect(leaves[0]).to eql([0, 0, 0])
+        expect(leaves[1]).to eql([0, 1, 1])
+        expect(leaves[2]).to eql([0, 2, 2])
+        expect(leaves[3]).to eql([1, 3])
+        expect(leaves[4]).to eql([2, 4])
+      end
+
+      it 'returns field access chains of deep containers' do
+        leaves = Norikra::FieldSet.leaves({'f1' => [{'fz1' => 1, 'fz2' => {'fz3' => 2, 'fz4' => 3}}, 4], 'f2' => 5})
+        expect(leaves.size).to eql(5)
+        expect(leaves[0]).to eql(['f1', 0, 'fz1', 1])
+        expect(leaves[1]).to eql(['f1', 0, 'fz2', 'fz3', 2])
+        expect(leaves[2]).to eql(['f1', 0, 'fz2', 'fz4', 3])
+        expect(leaves[3]).to eql(['f1', 1, 4])
+        expect(leaves[4]).to eql(['f2', 5])
+      end
+    end
+
     describe '.field_names_key' do
       it 'returns comma-separated sorted field names of argument hash' do
         expect(Norikra::FieldSet.field_names_key({'x1'=>1,'y3'=>2,'xx'=>3,'xx1'=>4,'a'=>5})).to eql('a,x1,xx,xx1,y3')
@@ -79,6 +91,32 @@ describe Norikra::FieldSet do
       it 'returns comma-separated sorted field names of argument hash AND non-optional fields of 2nd argument fieldset instance' do
         expect(Norikra::FieldSet.field_names_key({'x1'=>1,'y3'=>2,'xx'=>3,'xx1'=>4}, set)).to eql('a,x,x1,xx,xx1,y,y3')
       end
+
+      it 'returns only fields with defined previously in strict-mode' do
+        expect(Norikra::FieldSet.field_names_key({'x'=>1,'y'=>2,'xx'=>3,'xx1'=>4}, set, true)).to eql('a,x,y')
+      end
+
+      it 'returns fields also in additional_fields in strict-mode and additional_fields' do
+        expect(Norikra::FieldSet.field_names_key({'x'=>1,'y'=>2,'xx'=>3,'xx1'=>4,'xx2'=>5,'yy'=>6,'yy1'=>7}, set, true, ['xx2','yy1'])).to eql('a,x,xx2,y,yy1')
+      end
+
+      it 'returns result w/o chained field accesses not reserved (also in non-strict mode)' do
+        expect(Norikra::FieldSet.field_names_key({'x'=>1,'y'=>2,'z'=>{'x1'=>1,'x2'=>2}}, set, true, [])).to eql('a,x,y')
+        expect(Norikra::FieldSet.field_names_key({'x'=>1,'y'=>2,'z'=>{'x1'=>1,'x2'=>2}}, set, false, [])).to eql('a,x,y')
+      end
+
+      it 'returns result w/ reserved chained field accesses' do
+        expect(Norikra::FieldSet.field_names_key({'x'=>1,'y'=>2,'z'=>{'x1'=>1,'x2'=>2}}, set, false, ['z.x2'])).to eql('a,x,y,z.x2')
+        expect(Norikra::FieldSet.field_names_key({'x'=>1,'y'=>2,'z'=>{'x1'=>1,'x2'=>2}}, set, true, ['z.x1'])).to eql('a,x,y,z.x1')
+      end
+
+      it 'returns result w/ newly founded fields in non-strict mode, only for non-chained field accesses' do
+        expect(Norikra::FieldSet.field_names_key({'x'=>1,'y'=>2,'z'=>{'x1'=>1,'x2'=>2},'p'=>true}, set, false, [])).to eql('a,p,x,y')
+      end
+
+      it 'returns result w/ regulared names for chained field accesses' do
+        expect(Norikra::FieldSet.field_names_key({'x'=>1,'y'=>2,'z'=>['a','b','c']}, set, false, ['z.$0'])).to eql('a,x,y,z.$0')
+      end
     end
 
     describe '#field_names_key' do
@@ -208,5 +246,36 @@ describe Norikra::FieldSet do
         expect(x.event_type_name).to eql(internal)
       end
     end
+
+    describe '#format' do
+      it 'returns hash value with formatted fields as defined' do
+        t = Norikra::FieldSet.new({'a' => 'string', 'b' => 'long', 'c' => 'boolean', 'd' => 'double'})
+
+        d = t.format({'a'=>'hoge','b'=>'2000','c'=>'true','d'=>'3.14'})
+        expect(d['a']).to be_instance_of(String)
+        expect(d['a']).to eql('hoge')
+        expect(d['b']).to be_instance_of(Fixnum)
+        expect(d['b']).to eql(2000)
+        expect(d['c']).to be_instance_of(TrueClass)
+        expect(d['c']).to eql(true)
+        expect(d['d']).to be_instance_of(Float)
+        expect(d['d']).to eql(3.14)
+      end
+
+      it 'returns data with keys encoded for chained field accesses' do
+        t = Norikra::FieldSet.new({'a' => 'string', 'b' => 'long', 'e.$0' => 'string', 'f.foo.$$0' => 'string'})
+
+        d = t.format({'a'=>'hoge','b'=>'2000','c'=>'true','d'=>'3.14','e'=>['moris','tago'],'f'=>{'foo'=>{'0'=>'zero','1'=>'one'},'bar'=>{'0'=>'ZERO','1'=>'ONE'}}})
+        expect(d.size).to eql(4)
+        expect(d['a']).to be_instance_of(String)
+        expect(d['a']).to eql('hoge')
+        expect(d['b']).to be_instance_of(Fixnum)
+        expect(d['b']).to eql(2000)
+        expect(d['e$$0']).to be_instance_of(String)
+        expect(d['e$$0']).to eql('moris')
+        expect(d['f$foo$$$0']).to be_instance_of(String)
+        expect(d['f$foo$$$0']).to eql('zero')
+      end
+    end
   end
 end

data/spec/query_spec.rb

@@ -2,6 +2,8 @@ require_relative './spec_helper'
 
 require 'norikra/query'
 
+include Norikra::SpecHelper
+
 describe Norikra::Query do
   context 'when instanciate' do
     describe '#initialize' do
@@ -106,6 +108,40 @@ describe Norikra::Query do
           expect(q.fields(nil)).to eql([])
         end
       end
+
+      context 'with simple query including container field accesses' do
+        it 'returns query instances collectly parsed' do
+          expression = 'SELECT count(*) AS cnt FROM TestTable.win:time_batch(10 sec) WHERE params.path="/" AND size > 100 and opts.$0 > 0'
+          q = Norikra::Query.new(
+            :name => 'TestTable query7', :expression => expression
+          )
+          expect(q.name).to eql('TestTable query7')
+          expect(q.group).to be_nil
+          expect(q.expression).to eql(expression)
+          expect(q.targets).to eql(['TestTable'])
+
+          expect(q.fields).to eql(['params.path', 'size', 'opts.$0'].sort)
+          expect(q.fields('TestTable')).to eql(['params.path', 'size', 'opts.$0'].sort)
+          expect(q.fields(nil)).to eql([])
+        end
+      end
+
+      context 'with simple query including deep depth container field accesses and function calls' do
+        it 'returns query instances collectly parsed' do
+          expression = 'SELECT count(*) AS cnt FROM TestTable.win:time_batch(10 sec) WHERE params.$$path.$1="/" AND size.$0.bytes > 100 and opts.num.$0.length() > 0'
+          q = Norikra::Query.new(
+            :name => 'TestTable query8', :expression => expression
+          )
+          expect(q.name).to eql('TestTable query8')
+          expect(q.group).to be_nil
+          expect(q.expression).to eql(expression)
+          expect(q.targets).to eql(['TestTable'])
+
+          expect(q.fields).to eql(['params.$$path.$1', 'size.$0.bytes', 'opts.num.$0'].sort)
+          expect(q.fields('TestTable')).to eql(['params.$$path.$1', 'size.$0.bytes', 'opts.num.$0'].sort)
+          expect(q.fields(nil)).to eql([])
+        end
+      end
     end
 
     describe '#dup' do
@@ -132,39 +168,178 @@ describe Norikra::Query do
       end
     end
 
-    describe '#dup_with_stream_name' do
+    describe '.rewrite_event_field_name' do
+      context 'without any container field access' do
+        expression = 'select count(*) as cnt from TestTable.win:time_batch(10 seconds) where path = "/" and size > 100 and (param.length()) > 0'
+        it 'returns same query with original' do
+          with_engine do
+            model = administrator.compileEPL(expression)
+            expect(Norikra::Query.rewrite_event_field_name(model, {'TestTable' => 'T1'}).toEPL).to eql(expression)
+          end
+        end
+      end
+
+      context 'with container field access' do
+        expression = 'select max(result.$0.size) as cnt from TestTable.win:time_batch(10 seconds) where req.path = "/" and result.$0.size > 100 and (req.param.length()) > 0'
+        expected   = 'select max(result$$0$size) as cnt from TestTable.win:time_batch(10 seconds) where req$path = "/" and result$$0$size > 100 and (req$param.length()) > 0'
+        it 'returns query with encoded container fields' do
+          with_engine do
+            model = administrator.compileEPL(expression)
+            expect(Norikra::Query.rewrite_event_field_name(model, {'TestTable' => 'T1'}).toEPL).to eql(expected)
+          end
+        end
+      end
+
+      context 'with container field access with joins' do
+        expression = 'select product, max(sta.param.size) as maxsize from StreamA.win:keepall() as sta, StreamB(size > 10).win:time(20 seconds) as stb where (sta.data.$0.$$body.substr(0, 8)) = stb.header and (Math.abs(sta.size)) > 3'
+        expected   = 'select product, max(sta.param$size) as maxsize from StreamA.win:keepall() as sta, StreamB(size > 10).win:time(20 seconds) as stb where (sta.data$$0$$$body.substr(0, 8)) = stb.header and (Math.abs(sta.size)) > 3'
+        it 'returns query with encoded container fields' do
+          with_engine do
+            model = administrator.compileEPL(expression)
+            expect(Norikra::Query.rewrite_event_field_name(model, {'StreamA' => 'S1', 'StreamB' => 'S2'}).toEPL).to eql(expected)
+          end
+        end
+      end
+
+      context 'without any container field access, but with alias specification, without joins' do
+        expression = 'select count(*) as cnt from TestTable.win:time_batch(10 seconds) where path = "/" and TestTable.size > 100 and (param.length()) > 0'
+        expected =   'select count(*) as cnt from TestTable.win:time_batch(10 seconds) where path = "/" and T1.size > 100 and (param.length()) > 0'
+        it 'returns query expression' do
+          with_engine do
+            model = administrator.compileEPL(expression)
+            expect(Norikra::Query.rewrite_event_field_name(model, {'TestTable' => 'T1'}).toEPL).to eql(expected)
+          end
+        end
+      end
+
+      context 'with subquery in select clause' do
+        expression = 'select RfidEvent.zoneId.$0, (select name.x from Zones.std:unique(zoneName) where zoneId = RfidEvent.zoneId.$0) as name from RfidEvent'
+        expected   = 'select Z2.zoneId$$0, (select name$x from Zones.std:unique(zoneName) where zoneId = Z2.zoneId$$0) as name from RfidEvent'
+        it 'returns query model which have replaced stream name, for only targets of fully qualified field name access' do
+          with_engine do
+            model = administrator.compileEPL(expression)
+            expect(Norikra::Query.rewrite_event_field_name(model, {'Zones' => 'Z1', 'RfidEvent' => 'Z2'}).toEPL).to eql(expected)
+          end
+        end
+      end
+
+      context 'with container field accesses, with targets, aliases and joins' do
+        expression = 'select StreamA.product, max(sta.param.size) as maxsize from StreamA.win:keepall() as sta, StreamB(size > 10).win:time(20 seconds) as stb where (sta.data.$0.$$body.substr(0, 8)) = StreamB.header.$0 and (Math.abs(StreamA.size.$0.$$abs)) > 3'
+        expected   = 'select S1.product, max(sta.param$size) as maxsize from StreamA.win:keepall() as sta, StreamB(size > 10).win:time(20 seconds) as stb where (sta.data$$0$$$body.substr(0, 8)) = S2.header$$0 and (Math.abs(S1.size$$0$$$abs)) > 3'
+        it 'returns query model which have replaced stream name, for only targets of fully qualified field name access' do
+          with_engine do
+            model = administrator.compileEPL(expression)
+            expect(Norikra::Query.rewrite_event_field_name(model, {'StreamA' => 'S1', 'StreamB' => 'S2'}).toEPL).to eql(expected)
+          end
+        end
+      end
+    end
+
+    describe '.rewrite_event_type_name' do
       context 'with simple query' do
-        expression = 'SELECT count(*) AS cnt FROM TestTable.win:time_batch(10 sec) WHERE path="/" AND size > 100 and param.length() > 0'
-        it 'returns duplicated object, with replaced ' do
-          query = Norikra::Query.new(
-            :name => 'TestTable query1', :expression => expression
-          )
-          expect(query.dup_with_stream_name('hoge').expression).to eql(
-            'SELECT count(*) AS cnt FROM hoge.win:time_batch(10 sec) WHERE path="/" AND size > 100 and param.length() > 0'
-          )
+        expression = 'select count(*) as cnt from TestTable.win:time_batch(10 seconds) where path = "/" and size > 100 and (param.length()) > 0'
+
+        it 'returns query model which have replaced stream name' do
+          with_engine do
+            model = administrator.compileEPL(expression)
+            expect(Norikra::Query.rewrite_event_type_name(model, {'TestTable' => 'hoge'}).toEPL).to eql(expression.sub('TestTable','hoge'))
+          end
+        end
+      end
+      context 'with subquery in select clause' do
+        expression = 'select zoneId.$0, (select name.x from Zones.std:unique(zoneName) where zoneId = RfidEvent.zoneId.$0) as name from RfidEvent'
+        expected   = 'select zoneId.$0, (select name.x from Z1.std:unique(zoneName) where zoneId = RfidEvent.zoneId.$0) as name from Z2'
+        it 'returns query model which have replaced stream name, for only From clause' do
+          with_engine do
+            model = administrator.compileEPL(expression)
+            expect(Norikra::Query.rewrite_event_type_name(model, {'Zones' => 'Z1', 'RfidEvent' => 'Z2'}).toEPL).to eql(expected)
+          end
         end
       end
+      context 'with subquery in from clause' do
+        expression = "select * from BarData(ticker='MSFT', sub(closePrice, (select movAgv from SMA20Stream(ticker='MSFT').std:lastevent())) > 0)"
+        expected   = 'select * from B1(ticker = "MSFT" and (sub(closePrice, (select movAgv from B2(ticker = "MSFT").std:lastevent()))) > 0)'
+        it 'returns query model which have replaced stream name' do
+          with_engine do
+            model = administrator.compileEPL(expression)
+            expect(Norikra::Query.rewrite_event_type_name(model, {'BarData' => 'B1', 'SMA20Stream' => 'B2'}).toEPL).to eql(expected)
+          end
+        end
+      end
+      context 'with joins' do
+        expression = 'select product, max(sta.size) as maxsize from StreamA.win:keepall() as sta, StreamB(size > 10).win:time(20 seconds) as stb where (sta.data.substr(0, 8)) = stb.header and (Math.abs(sta.size)) > 3'
+        it 'returns query model which have replaced stream name' do
+          with_engine do
+            model = administrator.compileEPL(expression)
+            mapping = {'StreamA' => 'sa', 'StreamB' => 'sb'}
+            expect(Norikra::Query.rewrite_event_type_name(model, mapping).toEPL).to eql(expression.sub('StreamA','sa').sub('StreamB','sb'))
+          end
+        end
+      end
+    end
 
-      context 'with query with newlines' do
-        expression = <<EOQ
-SELECT
-  count(*) AS cnt
-FROM TestTable.win:time_batch(10 sec)
-WHERE path="/" AND size > 100
-  AND param.length() > 0
-EOQ
-        expected_query = <<EOQ
-SELECT
-  count(*) AS cnt
-FROM hoge.win:time_batch(10 sec)
-WHERE path="/" AND size > 100
-  AND param.length() > 0
-EOQ
-        it 'returns duplicated object, with replaced ' do
-          query = Norikra::Query.new(
-            :name => 'TestTable query1', :expression => expression
-          )
-          expect(query.dup_with_stream_name('hoge').expression).to eql(expected_query)
+    describe '.rewrite_query' do
+      it 'rewrites all of targets and container-field-accesses' do
+        with_engine do
+          e1 = 'select count(*) as cnt from TestTable.win:time_batch(10 seconds) where path = "/" and size > 100 and (param.length()) > 0'
+          x1 = 'select count(*) as cnt from T1.win:time_batch(10 seconds) where path = "/" and size > 100 and (param.length()) > 0'
+          model = administrator.compileEPL(e1)
+          mapping = {'TestTable' => 'T1'}
+          expect(Norikra::Query.rewrite_query(model, mapping).toEPL).to eql(x1)
+
+          e2 = 'select max(result.$0.size) as cnt from TestTable.win:time_batch(10 seconds) where req.path = "/" and result.$0.size > 100 and (req.param.length()) > 0'
+          x2 = 'select max(result$$0$size) as cnt from T1.win:time_batch(10 seconds) where req$path = "/" and result$$0$size > 100 and (req$param.length()) > 0'
+          model = administrator.compileEPL(e2)
+          mapping = {'TestTable' => 'T1'}
+          expect(Norikra::Query.rewrite_query(model, mapping).toEPL).to eql(x2)
+
+          e3 = 'select product, max(sta.param.size) as maxsize from StreamA.win:keepall() as sta, StreamB(size > 10).win:time(20 seconds) as stb where (sta.data.$0.$$body.substr(0, 8)) = stb.header and (Math.abs(sta.size)) > 3'
+          x3 = 'select product, max(sta.param$size) as maxsize from S1.win:keepall() as sta, S2(size > 10).win:time(20 seconds) as stb where (sta.data$$0$$$body.substr(0, 8)) = stb.header and (Math.abs(sta.size)) > 3'
+          model = administrator.compileEPL(e3)
+          mapping = {'StreamA' => 'S1', 'StreamB' => 'S2'}
+          expect(Norikra::Query.rewrite_query(model, mapping).toEPL).to eql(x3)
+
+          e4 = 'select count(*) as cnt from TestTable.win:time_batch(10 seconds) where path = "/" and TestTable.size > 100 and (param.length()) > 0'
+          x4 = 'select count(*) as cnt from T1.win:time_batch(10 seconds) where path = "/" and T1.size > 100 and (param.length()) > 0'
+          model = administrator.compileEPL(e4)
+          mapping = {'TestTable' => 'T1'}
+          expect(Norikra::Query.rewrite_query(model, mapping).toEPL).to eql(x4)
+
+          e5 = 'select RfidEvent.zoneId.$0, (select name.x from Zones.std:unique(zoneName) where zoneId = RfidEvent.zoneId.$0) as name from RfidEvent'
+          x5 = 'select R1.zoneId$$0, (select name$x from Z1.std:unique(zoneName) where zoneId = R1.zoneId$$0) as name from R1'
+          model = administrator.compileEPL(e5)
+          mapping = {'RfidEvent' => 'R1', 'Zones' => 'Z1'}
+          expect(Norikra::Query.rewrite_query(model, mapping).toEPL).to eql(x5)
+
+          e6 = 'select StreamA.product, max(sta.param.size) as maxsize from StreamA.win:keepall() as sta, StreamB(size > 10).win:time(20 seconds) as stb where (sta.data.$0.$$body.substr(0, 8)) = StreamB.header.$0 and (Math.abs(StreamA.size.$0.$$abs)) > 3'
+          x6 = 'select S1.product, max(sta.param$size) as maxsize from S1.win:keepall() as sta, S2(size > 10).win:time(20 seconds) as stb where (sta.data$$0$$$body.substr(0, 8)) = S2.header$$0 and (Math.abs(S1.size$$0$$$abs)) > 3'
+          model = administrator.compileEPL(e6)
+          mapping = {'StreamA' => 'S1', 'StreamB' => 'S2'}
+          expect(Norikra::Query.rewrite_query(model, mapping).toEPL).to eql(x6)
+
+          e7 = 'select count(*) as cnt from TestTable.win:time_batch(10 seconds) where path = "/" and size > 100 and (param.length()) > 0'
+          x7 = 'select count(*) as cnt from T1.win:time_batch(10 seconds) where path = "/" and size > 100 and (param.length()) > 0'
+          model = administrator.compileEPL(e7)
+          mapping = {'TestTable' => 'T1'}
+          expect(Norikra::Query.rewrite_query(model, mapping).toEPL).to eql(x7)
+
+          e8 = 'select RfidEvent.zoneId.$0, (select name.x from Zones.std:unique(zoneName) where zoneId = RfidEvent.zoneId.$0) as name from RfidEvent'
+          x8 = 'select R1.zoneId$$0, (select name$x from Z1.std:unique(zoneName) where zoneId = R1.zoneId$$0) as name from R1'
+          model = administrator.compileEPL(e8)
+          mapping = {'Zones' => 'Z1', 'RfidEvent' => 'R1'}
+          expect(Norikra::Query.rewrite_query(model, mapping).toEPL).to eql(x8)
+
+          e9 = 'select * from BarData(ticker = "MSFT" and (sub(closePrice, (select movAgv from SMA20Stream(ticker = "MSFT").std:lastevent())) > 0))'
+          x9 = 'select * from B1(ticker = "MSFT" and (sub(closePrice, (select movAgv from S1(ticker = "MSFT").std:lastevent()))) > 0)'
+          model = administrator.compileEPL(e9)
+          mapping = {'BarData' => 'B1', 'SMA20Stream' => 'S1'}
+          expect(Norikra::Query.rewrite_query(model, mapping).toEPL).to eql(x9)
+
+          e10 = 'select product, max(sta.size) as maxsize from StreamA.win:keepall() as sta, StreamB(size > 10).win:time(20 seconds) as stb where (sta.data.substr(0, 8)) = stb.header and (Math.abs(sta.size)) > 3'
+          x10 = 'select product, max(sta.size) as maxsize from S1.win:keepall() as sta, S2(size > 10).win:time(20 seconds) as stb where (sta.data.substr(0, 8)) = stb.header and (Math.abs(sta.size)) > 3'
+          model = administrator.compileEPL(e10)
+          mapping = {'StreamA' => 'S1', 'StreamB' => 'S2'}
+          expect(Norikra::Query.rewrite_query(model, mapping).toEPL).to eql(x10)
         end
       end
     end