norikra 0.1.6-java → 0.1.7-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0250e9866cf7d804dee32f348e8aa7832fbf5ef2
-  data.tar.gz: a91fb11a6ed74fd8bc2bc56108c62e4a4d3e8b0e
+  metadata.gz: c60623a71ba50774fd30d435b33ddd5abddb5a32
+  data.tar.gz: 4540758d58b47d144feaa504087a393a7853d380
 SHA512:
-  metadata.gz: 506b88f4cb736f441566f9ee02d34fbe7d2c990cddcf8bf8c30c2ebe907010a8dc44fc5586db57985d86fcf8f6aa784f09b80e12d8211147315621d230fbd8b6
-  data.tar.gz: 5913062545c129fcdd227260c1c0081ed8f7ff3682103f833f03e41740571be637ca35968e6264d94690900e62b499b0460270a14a1fcb2a5e5c6c9a0ab80f87
+  metadata.gz: fba4984d9d6c96573f169d5d7fe1f62e6bf711666c0546886d11fce7723beaaf64dce7a30d884b1c05870c7edce49603345e18d660c6d67824d408e22ef768ba
+  data.tar.gz: 3359da4c4bd851e4f2191ab859b902843619d17124da18b5fe6ab7f3c9fe1d07afed9d12b0e4579fc5b81c40ebba7db0a8035fe1e831dd0dea3ec7367c7d820f

data/lib/norikra/query.rb

@@ -260,22 +260,22 @@ module Norikra
       # Subqueries can only consist of a select clause, a from clause and a where clause.
       # The group by and having clauses, as well as joins, outer-joins and output rate limiting are not permitted within subqueries.
 
-      # model.getFromClause.getStreams[0].getFilter.setEventTypeName("hoge")
+      # model.getFromClause.getStreams[0].getFilter.setEventTypeName("hoge") # normal Stream
+      # model.getFromClause.getStreams[1].getExpression.getChildren[0].getChildren[0].getFilter.getEventTypeName # pattern
 
       # model.getSelectClause.getSelectList[1].getExpression => #<Java::ComEspertechEsperClientSoda::SubqueryExpression:0x3344c133>
       # model.getSelectClause.getSelectList[1].getExpression.getModel.getFromClause.getStreams[0].getFilter.getEventTypeName
       # model.getWhereClause.getChildren[1]                 .getModel.getFromClause.getStreams[0].getFilter.getEventTypeName
 
-      statement_model.getFromClause.getStreams.each do |stream|
-        target_name = stream.getFilter.getEventTypeName
-        unless mapping[target_name]
-          raise RuntimeError, "target missing in mapping, maybe BUG"
-        end
-        stream.getFilter.setEventTypeName(mapping[target_name])
-      end
-
       rewriter = lambda {|node|
-        # nothing for query expression clauses
+        if node.respond_to?(:getEventTypeName)
+          target_name = node.getEventTypeName
+          rewrite_name = mapping[ target_name ]
+          unless rewrite_name
+            raise RuntimeError, "target missing in mapping, maybe BUG: #{target_name}"
+          end
+          node.setEventTypeName(rewrite_name)
+        end
       }
       recaller = lambda {|node|
         Norikra::Query.rewrite_event_type_name(node.getModel, mapping)
@@ -314,6 +314,7 @@ module Norikra
     def self.traverse_fields(rewriter, recaller, statement_model)
       #NOTICE: SQLStream is not supported yet.
       dig = lambda {|node|
+        return unless node
         rewriter.call(node)
 
         if node.is_a?(Java::ComEspertechEsperClientSoda::SubqueryExpression)
@@ -344,7 +345,7 @@ module Norikra
           dig.call(stream.getExpression)
         end
         if stream.respond_to?(:getFilter) # Filter < ProjectedStream
-          dig.call(stream.getFilter.getFilter) #=> Expression
+          dig.call(stream.getFilter)
         end
         if stream.respond_to?(:getParameterExpressions) # MethodInvocationStream
           dig.call(stream.getParameterExpressions)

data/lib/norikra/query/ast.rb

@@ -210,6 +210,11 @@ module Norikra
       # "field.index("?")" => ["EVENT_PROP_EXPR", ["EVENT_PROP_SIMPLE", "path"], ["EVENT_PROP_MAPPED", "index", "\"?\""]]
       # "field.f1.index(".")" => ["EVENT_PROP_EXPR", ["EVENT_PROP_SIMPLE", "path"], ["EVENT_PROP_SIMPLE", "q1"], ["EVENT_PROP_MAPPED", "index", "\".\""]]
 
+      #### escapes: Oops!!!! unsupported yet.
+      # "`path name`" => ["EVENT_PROP_EXPR", ["EVENT_PROP_SIMPLE", "`path name`"]]
+      # "`T Table`.`path name`" => ["EVENT_PROP_EXPR", ["EVENT_PROP_SIMPLE", "`T Testing`"], ["EVENT_PROP_SIMPLE", "`path name`"]]
+      # "`size.num`" => ["EVENT_PROP_EXPR", ["EVENT_PROP_SIMPLE", "`size.num`"]]
+
       def nodetype?(*sym)
         sym.include?(:prop) || sym.include?(:property)
       end
@@ -258,6 +263,10 @@ module Norikra
       # 2nd child is bare-word (like [a-z][a-z0-9]*) -> this is function -> 1st child is receiver -> property
       # 2nd child is literal or property or none -> 1st child is built-in function
 
+      ### escaped name access
+      # "`T Table`.param.length()" => ["LIB_FUNC_CHAIN", ["LIB_FUNCTION", "TestTable Testing.param", "length", "("]]
+      ## Oops! we CANNOT support this syntax
+
       def nodetype?(*sym)
         sym.include?(:lib) || sym.include?(:libfunc)
       end

data/lib/norikra/version.rb

@@ -1,3 +1,3 @@
 module Norikra
-  VERSION = "0.1.6"
+  VERSION = "0.1.7"
 end

data/script/spec_server_pry

@@ -32,8 +32,8 @@ def administrator
   $administrator ||= service.getEPAdministrator
 end
 
-def compileEPL(query_str)
-  administrator.compileEPL(query_str)
+def compileEPL(query)
+  administrator.compileEPL(query.expression)
 end
 
 def query_string(model)
@@ -43,7 +43,11 @@ def query_string(model)
     model.toEPLElement(writer)
     writer.toString
   elsif model.respond_to?(:toPrecedenceFreeEPL)
-    model.toPrecedenceFreeEPL(writer)
+    begin
+      model.toPrecedenceFreeEPL(writer)
+    rescue ArgumentError
+      model.toPrecedenceFreeEPL(writer, formatter)
+    end
     writer.toString
   elsif model.is_a?(Java::ComEspertechEsperClientSoda::EPStatementObjectModel)
     model.toEPL
@@ -53,6 +57,16 @@ def query_string(model)
   end
 end
 
+def compiledExpression(query)
+  model = compileEPL(query)
+  mapping = {}
+  query.targets.each do |target|
+    mapping[target] = target
+  end
+  Norikra::Query.rewrite_query(model, mapping)
+  query_string(model)
+end
+
 puts <<DESC
 
 Example:

data/spec/query_spec.rb

@@ -24,6 +24,54 @@ describe Norikra::Query do
         end
       end
 
+      ### Escaped target/field names are not supported yet!
+      # context 'with escaped abnormal field name' do
+      #   it 'returns instance wrongly parsed for field with instance method call' do
+      #     expression = 'SELECT count(*) AS cnt FROM `TestTable Testing`.win:time_batch(10 sec) WHERE `path name`="/" AND size > 100 and `param string`.length() > 0'
+      #     q = Norikra::Query.new(
+      #       :name => 'TestTable query1.1', :expression => expression
+      #     )
+      #     expect(q.name).to eql('TestTable query1.1')
+      #     expect(q.group).to be_nil
+      #     expect(q.expression).to eql(expression)
+      #     expect(q.targets).to eql(['TestTable Testing'])
+
+      #     expect(q.fields).to eql(['param string', '`path name`', 'size'].sort)
+      #     expect(q.fields('TestTable Testing')).to eql(['param string','`path name`','size'].sort) # 'param string' is not escaped!
+      #     expect(q.fields(nil)).to eql([])
+      #   end
+
+      #   it 'returns instance correctly parsed w/ fully-qualified escaped name fields' do
+      #     expression = 'SELECT count(*) AS cnt FROM `TestTable Testing`.win:time_batch(10 sec) WHERE `TestTable Testing`.`path name`="/" AND `size.num` > 100 and `TestTable Testing`.param.length() > 0'
+      #     q = Norikra::Query.new(
+      #       :name => 'TestTable query1.2', :expression => expression
+      #     )
+      #     expect(q.name).to eql('TestTable query1.2')
+      #     expect(q.group).to be_nil
+      #     expect(q.expression).to eql(expression)
+      #     expect(q.targets).to eql(['TestTable Testing'])
+
+      #     expect(q.fields).to eql(['param', '`path name`', '`size.num`'].sort)
+      #     expect(q.fields('TestTable Testing')).to eql(['param','`path name`','`size.num`'].sort)
+      #     expect(q.fields(nil)).to eql([])
+      #   end
+
+      #   it 'returns instance correctly parsed w/ fully-qualified escaped name fields' do
+      #     expression = 'SELECT count(*) AS cnt FROM `TestTable Testing`.win:time_batch(10 sec) WHERE path\.name="/" AND size\.num > 100 and `TestTable Testing`.param\.name.length() > 0'
+      #     q = Norikra::Query.new(
+      #       :name => 'TestTable query1.3', :expression => expression
+      #     )
+      #     expect(q.name).to eql('TestTable query1.3')
+      #     expect(q.group).to be_nil
+      #     expect(q.expression).to eql(expression)
+      #     expect(q.targets).to eql(['TestTable Testing'])
+
+      #     expect(q.fields).to eql(['param\.name', 'path\.name', 'size\.num'].sort)
+      #     expect(q.fields('TestTable Testing')).to eql(['param\.name', 'path\.name', 'size\.num'].sort)
+      #     expect(q.fields(nil)).to eql([])
+      #   end
+      # end
+
       context 'with top-level built-in functions' do
         it 'returns query instances collectly parsed' do
           expression = 'SELECT rate(10) FROM TestTable output snapshot every 2 sec'
@@ -90,6 +138,21 @@ describe Norikra::Query do
           expect(q.fields('StreamB')).to eql(['size','header'].sort)
           expect(q.fields(nil)).to eql(['product'])
         end
+
+        it 'returns query instances collectly parsed, with field accessing views' do
+          expression = 'select product, max(sta.size) as maxsize from StreamA.win:ext_timed_batch(ts1, 1 hours, 0L) as sta, StreamB(size > 10).win:ext_timed_batch(ts2, 20 sec) as stb where sta.data.substr(0,8) = stb.header AND Math.abs(sta.size) > 3'
+          q = Norikra::Query.new(
+            :name => 'TestTable query3.1', :expression => expression
+          )
+          expect(q.name).to eql('TestTable query3.1')
+          expect(q.expression).to eql(expression)
+          expect(q.targets).to eql(['StreamA', 'StreamB'])
+
+          expect(q.fields).to eql(['product', 'size', 'ts1', 'data', 'header', 'ts2'].sort)
+          expect(q.fields('StreamA')).to eql(['size','data','ts1'].sort)
+          expect(q.fields('StreamB')).to eql(['size','header','ts2'].sort)
+          expect(q.fields(nil)).to eql(['product'])
+        end
       end
 
       context 'with query with subquery (where clause)' do
@@ -189,6 +252,16 @@ describe Norikra::Query do
         end
       end
 
+      context 'with simple query and views with field reference' do
+        it 'returns query instances collectly parsed' do
+          expression = 'SELECT count(*) AS c FROM TestTable.win:ext_timed_batch(ts, 1 min, 0L) WHERE path.source.length() > 0'
+          q = Norikra::Query.new(:name => 'TestTable query8.3', :expression => expression)
+          expect(q.fields).to eql(['path.source', 'ts'].sort)
+          expect(q.fields('TestTable')).to eql(['path.source', 'ts'].sort)
+          expect(q.fields(nil)).to eql([])
+        end
+      end
+
       context 'with query with patterns' do
         it 'returns query instances collectly parsed' do
 
@@ -352,6 +425,20 @@ describe Norikra::Query do
           mapping = {'TestTable' => 'T1'}
           expect(Norikra::Query.rewrite_query(model, mapping).toEPL).to eql(x1)
 
+          ## not supported yet!
+          # # escaped abnormal field name / target name
+          # e1a = 'select count(*) as cnt from `TestTable Testing`.win:time_batch(10 sec) where `TestTable testing`.`path name`="/" and size > 100 and param.length() > 0'
+          # x1a = 'select count(*) as cnt from T2.win:time_batch(10 seconds) where T2.`path name`="/" and size > 100 and (param.length()) > 0'
+          # model = administrator.compileEPL(e1a)
+          # mapping = {'TestTable Testing' => 'T2'}
+          # expect(Norikra::Query.rewrite_query(model, mapping).toEPL).to eql(x1a)
+
+          # e1b = 'select count(*) as cnt from `TestTable Testing`.win:time_batch(10 sec) where path\.name="/" and size\.num > 100 and `testtable testing`.param\.name.length() > 0'
+          # x1b = 'select count(*) as cnt from T2.win:time_batch(10 seconcds) where path\.name="/" and size\.num > 100 and T2.param\.name.length() > 0'
+          # model = administrator.compileEPL(e1b)
+          # mapping = {'TestTable Testing' => 'T2'}
+          # 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'
@@ -380,6 +467,12 @@ describe Norikra::Query do
           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'
+          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'
@@ -450,6 +543,13 @@ describe Norikra::Query do
           model = administrator.compileEPL(e13)
           mapping = {'logs' => 'L111'}
           expect(Norikra::Query.rewrite_query(model, mapping).toEPL).to eql(x13)
+
+          # 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)]'
+          model = administrator.compileEPL(e14)
+          mapping = {'TestTable' => 'T1'}
+          expect(Norikra::Query.rewrite_query(model, mapping).toEPL).to eql(x14)
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: norikra
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: java
 authors:
 - TAGOMORI Satoshi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-03-31 00:00:00.000000000 Z
+date: 2014-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mizuno