norikra 0.1.7-java → 1.0.0-java

data/spec/field_spec.rb

@@ -145,9 +145,10 @@ describe Norikra::Field do
         expect(f.format(' ')).to eql(' ')
         expect(f.format(true)).to eql('true')
         expect(f.format(false)).to eql('false')
-        expect(f.format(nil)).to eql('')
-        expect(f.format({})).to eql('{}')
-        expect(f.format([])).to eql('[]')
+
+        expect(f.format(nil)).to be_nil
+        expect(f.format({})).to be_nil
+        expect(f.format([])).to be_nil
       end
     end
   end
@@ -158,11 +159,14 @@ describe Norikra::Field do
         f = Norikra::Field.new('x', 'boolean')
         expect(f.format(true)).to eql(true)
         expect(f.format(false)).to eql(false)
-        expect(f.format(nil)).to eql(false)
         expect(f.format('')).to eql(true)
 
         expect(f.format('true')).to eql(true)
         expect(f.format('false')).to eql(false)
+
+        expect(f.format(nil)).to be_nil
+        expect(f.format({})).to be_nil
+        expect(f.format([])).to be_nil
       end
     end
   end
@@ -177,7 +181,9 @@ describe Norikra::Field do
         expect(f.format('.1')).to eql(0)
         expect(f.format('')).to eql(0)
         expect(f.format(' ')).to eql(0)
-        expect(f.format(nil)).to eql(0)
+        expect(f.format(nil)).to be_nil
+        expect(f.format({})).to be_nil
+        expect(f.format([])).to be_nil
 
         f = Norikra::Field.new('x', 'long')
         expect(f.format('1')).to eql(1)
@@ -186,7 +192,9 @@ describe Norikra::Field do
         expect(f.format('.1')).to eql(0)
         expect(f.format('')).to eql(0)
         expect(f.format(' ')).to eql(0)
-        expect(f.format(nil)).to eql(0)
+        expect(f.format(nil)).to be_nil
+        expect(f.format({})).to be_nil
+        expect(f.format([])).to be_nil
 
         f = Norikra::Field.new('x', 'float')
         expect(f.format('1')).to eql(1.0)
@@ -195,7 +203,9 @@ describe Norikra::Field do
         expect(f.format('.1')).to eql(0.1)
         expect(f.format('')).to eql(0.0)
         expect(f.format(' ')).to eql(0.0)
-        expect(f.format(nil)).to eql(0.0)
+        expect(f.format(nil)).to be_nil
+        expect(f.format({})).to be_nil
+        expect(f.format([])).to be_nil
 
         f = Norikra::Field.new('x', 'double')
         expect(f.format('1')).to eql(1.0)
@@ -204,7 +214,9 @@ describe Norikra::Field do
         expect(f.format('.1')).to eql(0.1)
         expect(f.format('')).to eql(0.0)
         expect(f.format(' ')).to eql(0.0)
-        expect(f.format(nil)).to eql(0.0)
+        expect(f.format(nil)).to be_nil
+        expect(f.format({})).to be_nil
+        expect(f.format([])).to be_nil
       end
     end
   end

data/spec/fieldset_spec.rb

@@ -350,6 +350,17 @@ describe Norikra::FieldSet do
         expect(d['f$foo$$$0']).to be_instance_of(String)
         expect(d['f$foo$$$0']).to eql('zero')
       end
+
+      it 'returns nil for value field but events has nested record' do
+        t = Norikra::FieldSet.new({'a' => 'string', 'b' => 'boolean', 'c' => 'long', 'd.$0' => 'double'})
+
+        d = t.format({'a'=>{'a1'=>"1"}, 'b'=>[1,2,3], 'c'=>{'cc'=>0.01}, 'd' => [ {'value'=>0.1} ]})
+        expect(d.size).to eql(4)
+        expect(d['a']).to be_nil
+        expect(d['b']).to be_nil
+        expect(d['c']).to be_nil
+        expect(d['d$$0']).to be_nil
+      end
     end
   end
 end

data/spec/query_spec.rb

@@ -281,6 +281,25 @@ describe Norikra::Query do
       end
     end
 
+    describe '.looback' do
+      it 'returns nil for nil group' do
+        expect(Norikra::Query.loopback(nil)).to be_nil
+      end
+
+      it 'returns nil for string group name without prefix' do
+        expect(Norikra::Query.loopback('a')).to be_nil
+        expect(Norikra::Query.loopback('group1')).to be_nil
+        expect(Norikra::Query.loopback('LOOPBACK')).to be_nil
+      end
+
+      it 'returns specified string as loopback target by parentheses' do
+        expect(Norikra::Query.loopback('LOOPBACK()')).to be_nil
+        expect(Norikra::Query.loopback('LOOPBACK(a)')).to eql('a')
+        expect(Norikra::Query.loopback('LOOPBACK(loopback_target)')).to eql('loopback_target')
+        expect(Norikra::Query.loopback('LOOPBACK(target name)')).to eql('target name') # should be invalid on 'open'
+      end
+    end
+
     describe '#dup' do
       context 'for queries without group (default group)' do
         it 'returns query object with default group' do
@@ -307,7 +326,7 @@ describe Norikra::Query 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'
+        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)
@@ -317,8 +336,8 @@ describe Norikra::Query do
       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'
+        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)
@@ -328,8 +347,8 @@ describe Norikra::Query do
       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'
+        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)
@@ -339,8 +358,8 @@ describe Norikra::Query do
       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'
+        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)
@@ -350,8 +369,8 @@ describe Norikra::Query do
       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'
+        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)
@@ -361,8 +380,8 @@ describe Norikra::Query do
       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'
+        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)
@@ -374,7 +393,7 @@ describe Norikra::Query do
 
     describe '.rewrite_event_type_name' do
       context 'with simple query' do
-        expression = 'select count(*) as cnt from TestTable.win:time_batch(10 seconds) 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
@@ -384,8 +403,8 @@ describe Norikra::Query do
         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'
+        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)
@@ -394,8 +413,8 @@ describe Norikra::Query do
         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)'
+        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)
@@ -404,7 +423,7 @@ describe Norikra::Query do
         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'
+        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)
@@ -416,11 +435,11 @@ describe Norikra::Query do
     end
 
     describe '.rewrite_query' do
-      it 'rewrites all of targets and container-field-accesses' do
+      it 'rewrites all of targets and container-field-accesses, for single simple query' do
         with_engine do
           # single simple query
-          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'
+          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)
@@ -440,113 +459,203 @@ describe Norikra::Query do
           # expect(Norikra::Query.rewrite_query(model, mapping).toEPL).to eql(x1b)
 
           # nested container field access
-          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'
+          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)
+        end
+      end
 
+      it 'rewrites targets/container field accesses w/ function calls and aliases' do
+        with_engine do
           # nested container field access w/ function call and alias
-          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'
+          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)
 
           # nested function call
-          e3a = 'select path.substring(0, path.index("?")) as urlpath, count(*) as count from TestTable.win:time_batch(60 seconds) group by path.substring(0, path.index("?"))'
-          x3a = 'select path.substring(0, path.index("?")) as urlpath, count(*) as count from T1.win:time_batch(60 seconds) group by path.substring(0, path.index("?"))'
+          e3a = 'select path.substring(0,path.index("?")) as urlpath, count(*) as count from TestTable.win:time_batch(60 seconds) group by path.substring(0,path.index("?"))'
+          x3a = 'select path.substring(0,path.index("?")) as urlpath, count(*) as count from T1.win:time_batch(60 seconds) group by path.substring(0,path.index("?"))'
           model = administrator.compileEPL(e3a)
           mapping = {'TestTable' => 'T1'}
           expect(Norikra::Query.rewrite_query(model, mapping).toEPL).to eql(x3a)
 
           # nested function call w/ container field access
-          e3b = 'select path.f1.substring(0, path.f1.index("?")) as urlpath, count(*) as count from TestTable.win:time_batch(60 seconds) group by path.f1.substring(0, path.f1.index("?"))'
-          x3b = 'select path$f1.substring(0, path$f1.index("?")) as urlpath, count(*) as count from T1.win:time_batch(60 seconds) group by path$f1.substring(0, path$f1.index("?"))'
+          e3b = 'select path.f1.substring(0,path.f1.index("?")) as urlpath, count(*) as count from TestTable.win:time_batch(60 seconds) group by path.f1.substring(0,path.f1.index("?"))'
+          x3b = 'select path$f1.substring(0,path$f1.index("?")) as urlpath, count(*) as count from T1.win:time_batch(60 seconds) group by path$f1.substring(0,path$f1.index("?"))'
           model = administrator.compileEPL(e3b)
           mapping = {'TestTable' => 'T1'}
           expect(Norikra::Query.rewrite_query(model, mapping).toEPL).to eql(x3b)
 
           # views w/ field access
-          e3c = 'select count(*) as c from TestTable.win:ext_timed_batch(TestTable.ts, 1 min, 0L) where path.source.length() > 0'
-          x3c = 'select count(*) as c from T1.win:ext_timed_batch(T1.ts, 1 minutes, 0L) where (path$source.length()) > 0'
+          e3c = 'select count(*) as c from TestTable.win:ext_timed_batch(TestTable.ts,1 min,0L) where path.source.length()>0'
+          x3c = 'select count(*) as c from T1.win:ext_timed_batch(T1.ts,1 minutes,0L) where (path$source.length())>0'
           model = administrator.compileEPL(e3c)
           mapping = {'TestTable' => 'T1'}
           expect(Norikra::Query.rewrite_query(model, mapping).toEPL).to eql(x3c)
 
           # Fully-qualified field access
-          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'
+          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)
 
           # Fully-qualified field access w/ container field access
-          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'
+          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)
+        end
+      end
 
+      it 'rewrites targets and container field accesses with JOINs and SubQueries' do
+        with_engine do
           # Fully-qualified field access w/ container field access and function calls, JOINs
-          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'
+          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)
 
           # ??? simple query
-          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'
+          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)
 
           # subquery
-          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'
+          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)
 
           # filters and subquery
-          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)'
+          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)
 
           # JOINs
-          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'
+          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
 
+      it 'rewrites targets and container field accesses with GROUP BY' do
+        with_engine do
           # GROUP BY clause
-          e11 = 'select applog.campaign.id as campaign_id, member.region as region, member.lang as lang, count(*) as click, count(distinct member.id) as uu from applog.win:time_batch(1 minutes) where type = "click" group by applog.campaign.id, member.region, member.lang'
-          x11 = 'select A1.campaign$id as campaign_id, member$region as region, member$lang as lang, count(*) as click, count(distinct member$id) as uu from A1.win:time_batch(1 minutes) where type = "click" group by A1.campaign$id, member$region, member$lang'
+          e11 = 'select applog.campaign.id as campaign_id, member.region as region, member.lang as lang, count(*) as click, count(distinct member.id) as uu from applog.win:time_batch(1 minutes) where type="click" group by applog.campaign.id, member.region, member.lang'
+          x11 = 'select A1.campaign$id as campaign_id, member$region as region, member$lang as lang, count(*) as click, count(distinct member$id) as uu from A1.win:time_batch(1 minutes) where type="click" group by A1.campaign$id, member$region, member$lang'
           model = administrator.compileEPL(e11)
           mapping = {'applog' => 'A1'}
           expect(Norikra::Query.rewrite_query(model, mapping).toEPL).to eql(x11)
 
+          # GROUP BY with MIN()/MAX()
+          e11a = 'select applog.campaign.id as campaign_id, member.region as region, member.lang as lang, MIN(login.times) as min, MAX(login.times) as max, count(*) as click, count(distinct member.id) as uu from applog.win:time_batch(1 minutes) where type="click" group by applog.campaign.id, member.region, member.lang'
+          x11a = 'select A1.campaign$id as campaign_id, member$region as region, member$lang as lang, min(login$times) as min, max(login$times) as max, count(*) as click, count(distinct member$id) as uu from A1.win:time_batch(1 minutes) where type="click" group by A1.campaign$id, member$region, member$lang'
+          q11a = Norikra::Query.new(name: 'q11a', expression: e11a)
+          model = administrator.compileEPL(q11a.expression)
+          mapping = {'applog' => 'A1'}
+          expect(Norikra::Query.rewrite_query(model, mapping).toEPL).to eql(x11a)
+        end
+      end
+
+      it 'rewrites targets and container field accesses with GROUP BY ROLLUP' do
+        with_engine do
+          e1 = 'select f1.$0.Symbol, StockTickEvent.data.feed, sum(f1.volume) from StockTickEvent.win:time_batch(30 seconds) as event group by rollup(f1.$0.Symbol, StockTickEvent.data.feed)'
+          x1 = 'select f1$$0$Symbol, S1.data$feed, sum(f1$volume) from S1.win:time_batch(30 seconds) as event group by rollup(f1$$0$Symbol, S1.data$feed)'
+          model = administrator.compileEPL(e1)
+          mapping = {'StockTickEvent' => 'S1'}
+          expect(Norikra::Query.rewrite_query(model, mapping).toEPL).to eql(x1)
+        end
+      end
+
+      it 'rewrites targets and container field accesses with GROUP BY CUBE' do
+        with_engine do
+          e1 = 'select f1.$0.Symbol, StockTickEvent.data.feed, sum(f1.volume) from StockTickEvent.win:time_batch(30 seconds) as event group by cube(f1.$0.Symbol, StockTickEvent.data.feed)'
+          x1 = 'select f1$$0$Symbol, S1.data$feed, sum(f1$volume) from S1.win:time_batch(30 seconds) as event group by cube(f1$$0$Symbol, S1.data$feed)'
+          model = administrator.compileEPL(e1)
+          mapping = {'StockTickEvent' => 'S1'}
+          expect(Norikra::Query.rewrite_query(model, mapping).toEPL).to eql(x1)
+        end
+      end
+
+      it 'rewrites targets and container field accesses with GROUP BY GROUPING SETS' do
+        with_engine do
+          e1 = 'select f1.$0.Symbol, StockTickEvent.data.feed, sum(f1.volume) from StockTickEvent.win:time_batch(30 seconds) as event group by grouping sets(f1.$0.Symbol, StockTickEvent.data.feed)'
+          x1 = 'select f1$$0$Symbol, S1.data$feed, sum(f1$volume) from S1.win:time_batch(30 seconds) as event group by grouping sets(f1$$0$Symbol, S1.data$feed)'
+          model = administrator.compileEPL(e1)
+          mapping = {'StockTickEvent' => 'S1'}
+          expect(Norikra::Query.rewrite_query(model, mapping).toEPL).to eql(x1)
+        end
+      end
+
+      it 'rewrites targets and container field accesses with GROUP BY using complex combinations' do
+        with_engine do
+          e1 = 'select f1.$0.Symbol, StockTickEvent.data.feed, sum(f1.volume) from StockTickEvent.win:time_batch(30 seconds) as event group by f1.$0.Symbol, rollup(StockTickEvent.data.feed)'
+          x1 = 'select f1$$0$Symbol, S1.data$feed, sum(f1$volume) from S1.win:time_batch(30 seconds) as event group by f1$$0$Symbol, rollup(S1.data$feed)'
+          model = administrator.compileEPL(e1)
+          mapping = {'StockTickEvent' => 'S1'}
+          expect(Norikra::Query.rewrite_query(model, mapping).toEPL).to eql(x1)
+
+          e2 = 'select f1.$0.Symbol, StockTickEvent.data.feed, sum(f1.volume) from StockTickEvent.win:time_batch(30 seconds) as event group by grouping sets((f1.$0.Symbol, StockTickEvent.data.feed), f1.$0.Symbol)'
+          x2 = 'select f1$$0$Symbol, S1.data$feed, sum(f1$volume) from S1.win:time_batch(30 seconds) as event group by grouping sets((f1$$0$Symbol, S1.data$feed), f1$$0$Symbol)'
+          model = administrator.compileEPL(e2)
+          mapping = {'StockTickEvent' => 'S1'}
+          expect(Norikra::Query.rewrite_query(model, mapping).toEPL).to eql(x2)
+
+          e3 = 'select f1.$0.Symbol, StockTickEvent.data.feed, sum(f1.volume) from StockTickEvent.win:time_batch(30 seconds) as event group by grouping sets(f1.$0.Symbol, StockTickEvent.data.feed, ())'
+          x3 = 'select f1$$0$Symbol, S1.data$feed, sum(f1$volume) from S1.win:time_batch(30 seconds) as event group by grouping sets(f1$$0$Symbol, S1.data$feed, ())'
+          model = administrator.compileEPL(e3)
+          mapping = {'StockTickEvent' => 'S1'}
+          expect(Norikra::Query.rewrite_query(model, mapping).toEPL).to eql(x3)
+
+          e4 = 'select f1.$0.Symbol, StockTickEvent.data.feed, sum(f1.volume) from StockTickEvent.win:time_batch(30 seconds) as event group by grouping sets(rollup(f1.$0.Symbol, StockTickEvent.data.feed), StockTickEvent.data.feed)'
+          x4 = 'select f1$$0$Symbol, S1.data$feed, sum(f1$volume) from S1.win:time_batch(30 seconds) as event group by grouping sets(rollup(f1$$0$Symbol, S1.data$feed), S1.data$feed)'
+          model = administrator.compileEPL(e4)
+          mapping = {'StockTickEvent' => 'S1'}
+          expect(Norikra::Query.rewrite_query(model, mapping).toEPL).to eql(x4)
+        end
+      end
+
+      it 'rewrites targets and container field accesses with ORDER BY' do
+        with_engine do
           # ORDER BY clause
-          e12 = 'select campaign.id, member.region as region, member.lang as lang, count(*) as click, count(distinct member.id) as uu from applog.win:time_batch(1 minutes) where type = "click" group by campaign.id, member.region, member.lang order by campaign.id'
-          x12 = 'select campaign$id, member$region as region, member$lang as lang, count(*) as click, count(distinct member$id) as uu from A1.win:time_batch(1 minutes) where type = "click" group by campaign$id, member$region, member$lang order by campaign$id'
+          e12 = 'select campaign.id, member.region as region, member.lang as lang, count(*) as click, count(distinct member.id) as uu from applog.win:time_batch(1 minutes) where type="click" group by campaign.id, member.region, member.lang order by campaign.id'
+          x12 = 'select campaign$id, member$region as region, member$lang as lang, count(*) as click, count(distinct member$id) as uu from A1.win:time_batch(1 minutes) where type="click" group by campaign$id, member$region, member$lang order by campaign$id'
           model = administrator.compileEPL(e12)
           mapping = {'applog' => 'A1'}
           expect(Norikra::Query.rewrite_query(model, mapping).toEPL).to eql(x12)
+        end
+      end
 
+      it 'rewrites targets and container field accesses with HAVING' do
+        with_engine do
           # HAVING clause
-          e13 = 'select path, max(response.duration) from logs.win:time_batch(10 seconds) where path.startsWith("/api/") group by path having max(response.duration) >= 100'
-          x13 = 'select path, max(response$duration) from L111.win:time_batch(10 seconds) where path.startsWith("/api/") group by path having max(response$duration) >= 100'
+          e13 = 'select path, max(response.duration) from logs.win:time_batch(10 seconds) where path.startsWith("/api/") group by path having max(response.duration)>=100'
+          x13 = 'select path, max(response$duration) from L111.win:time_batch(10 seconds) where path.startsWith("/api/") group by path having max(response$duration)>=100'
           model = administrator.compileEPL(e13)
           mapping = {'logs' => 'L111'}
           expect(Norikra::Query.rewrite_query(model, mapping).toEPL).to eql(x13)
+        end
+      end
 
+      it 'rewrites targets and container field accesses with Patterns' do
+        with_engine do
           # Pattern
-          e14 = 'select a.type from pattern [every a=TestTable -> b=TestTable(type = a.type)]'
-          x14 = 'select a.type from pattern [every a=T1 -> b=T1(type = a.type)]'
+          e14 = 'select a.type from pattern [every a=TestTable -> b=TestTable(type=a.type)]'
+          x14 = 'select a.type from pattern [every a=T1 -> b=T1(type=a.type)]'
           model = administrator.compileEPL(e14)
           mapping = {'TestTable' => 'T1'}
           expect(Norikra::Query.rewrite_query(model, mapping).toEPL).to eql(x14)