norikra 0.1.0-java → 0.1.1-java

data/README.md

@@ -1,6 +1,6 @@
 # Norikra
 
-Norikra is a open-source Stream Processing Server with SQL.
+Norikra is an open-source Stream Processing Server with SQL.
  * Schema-less event streams (called as 'target')
  * SQL processing with window specifier supports, and JOINs, SubQueries
  * Complex input/output events with nested Hashes and Arrays, and Query supports
@@ -68,10 +68,10 @@ For other languages:
 
 For example, think about event streams related with one web service (ex: 'www'). At first, define `target` with mandantory fields (in other words, minimal fields set for variations of 'www' events).
 
-    norikra-client target add www path:string status:integer referer:string agent:string userid:integer
+    norikra-client target open www path:string status:integer referer:string agent:string userid:integer
     norikra-client target list
 
-Supported types are `string`, `boolean`, `int`, `long`, `float`, `double` and `hash`, `array`.
+Supported types are `string`, `boolean`, `integer`, `float` and `hash`, `array`.
 
 You can register queries when you want.
 
@@ -120,6 +120,8 @@ TBD
 
 * v0.1.0:
  * First release for production
+* v0.1.1:
+ * Fix types more explicitly for users ('int/long' -> 'integer', 'float/double' -> 'float')
 
 ## Copyright
 

data/lib/norikra/field.rb

@@ -2,6 +2,14 @@ require 'norikra/error'
 
 module Norikra
   class Field
+    ### norikra types
+    # string
+    # boolean (alias: bool)
+    # integer (alias: int, long)
+    # float   (alias: double)
+    # hash
+    # array
+
     ### esper types
     ### http://esper.codehaus.org/esper-4.9.0/doc/reference/en-US/html/epl_clauses.html#epl-syntax-datatype
     # string  A single character to an unlimited number of characters.
@@ -27,11 +35,49 @@ module Norikra
     ### expected java.lang.Class or java.util.Map or the name of a previously-declared Map or ObjectArray type
     #### Correct type name is 'int'. see and run 'junks/esper-test.rb'
 
-    attr_accessor :name, :type, :optional, :escaped_name, :container_name, :container_type
+    attr_accessor :name, :type, :esper_type, :optional, :escaped_name, :container_name, :container_type
+
+    def self.esper_type_map(type)
+      case type.to_s.downcase
+      when 'string' then 'string'
+      when 'boolean', 'bool' then 'boolean'
+      when 'integer', 'int', 'long' then 'long'
+      when 'float', 'double' then 'double'
+      when 'hash', 'array'
+        raise Norikra::ArgumentError, "#{type} is norikra internal type, not for esper"
+      when 'byte'
+        raise Norikra::ArgumentError, "byte is not supported in Norikra"
+      else
+        raise Norikra::ArgumentError, "unknown type:#{type}"
+      end
+    end
+
+    def self.container_type?(type)
+      case type.to_s.downcase
+      when 'hash','array' then true
+      else
+        false
+      end
+    end
+
+    def self.valid_type(type)
+      case type.to_s.downcase
+      when 'string' then 'string'
+      when 'boolean', 'bool' then 'boolean'
+      when 'integer', 'int', 'long' then 'integer'
+      when 'float', 'double' then 'float'
+      when 'hash' then 'hash'
+      when 'array' then 'array'
+      when 'byte'
+        raise Norikra::ArgumentError, "byte is not supported in Norikra"
+      else
+        raise Norikra::ArgumentError, "invalid field type '#{type}'"
+      end
+    end
 
     def initialize(name, type, optional=nil)
       @name = name.to_s
-      @type = self.class.valid_type?(type)
+      @type = self.class.valid_type(type)
       @optional = optional
 
       @escaped_name = self.class.escape_name(@name)
@@ -49,12 +95,16 @@ module Norikra
       define_value_accessor(@name, @chained_access)
     end
 
+    def chained_access?
+      @chained_access
+    end
+
     def container_field?
-      @type == 'hash' || @type == 'array'
+      self.class.container_type?(@type)
     end
 
-    def chained_access?
-      @chained_access
+    def esper_type
+      self.class.esper_type_map(@type)
     end
 
     def self.escape_name(name)
@@ -122,38 +172,14 @@ module Norikra
       @optional
     end
 
-    def self.container_type?(type)
-      case type.to_s.downcase
-      when 'hash' then true
-      when 'array' then true
-      else
-        false
-      end
-    end
-
-    def self.valid_type?(type)
-      case type.to_s.downcase
-      when 'string' then 'string'
-      when 'boolean' then 'boolean'
-      when 'int' then 'int'
-      when 'long' then 'long'
-      when 'float' then 'float'
-      when 'double' then 'double'
-      when 'hash' then 'hash'
-      when 'array' then 'array'
-      else
-        raise Norikra::ArgumentError, "invalid field type '#{type}'"
-      end
-    end
-
     # def value(event) # by define_value_accessor
 
     def format(value, element_path=nil) #element_path ex: 'fname.fchild', 'fname.$0', 'f.fchild.$2'
       case @type
       when 'string'  then value.to_s
       when 'boolean' then value =~ /^(true|false)$/i ? ($1.downcase == 'true') : (!!value)
-      when 'long','int' then value.to_i
-      when 'double','float' then value.to_f
+      when 'integer' then value.to_i
+      when 'float' then value.to_f
       when 'hash', 'array'
         raise RuntimeError, "container field not permitted to access directly, maybe BUG. name:#{@name},type:#{@type}"
       else

data/lib/norikra/fieldset.rb

@@ -133,7 +133,7 @@ module Norikra
     def definition
       d = {}
       @fields.each do |key, field|
-        d[field.escaped_name] = field.type
+        d[field.escaped_name] = field.esper_type
       end
       d
     end

data/lib/norikra/version.rb

@@ -1,3 +1,3 @@
 module Norikra
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/spec/field_spec.rb

@@ -76,23 +76,23 @@ describe Norikra::Field do
     end
   end
 
-  describe '.valid_type?' do
+  describe '.valid_type' do
     it 'returns normalized type strings' do
-      expect(Norikra::Field.valid_type?('String')).to eql('string')
-      expect(Norikra::Field.valid_type?('STRING')).to eql('string')
-      expect(Norikra::Field.valid_type?(:string)).to eql('string')
-      expect(Norikra::Field.valid_type?('string')).to eql('string')
-
-      expect(Norikra::Field.valid_type?('boolean')).to eql('boolean')
-      expect(Norikra::Field.valid_type?('BOOLEAN')).to eql('boolean')
-      expect(Norikra::Field.valid_type?('Int')).to eql('int')
-      expect(Norikra::Field.valid_type?('lonG')).to eql('long')
-      expect(Norikra::Field.valid_type?('FLOAT')).to eql('float')
-      expect(Norikra::Field.valid_type?('Double')).to eql('double')
+      expect(Norikra::Field.valid_type('String')).to eql('string')
+      expect(Norikra::Field.valid_type('STRING')).to eql('string')
+      expect(Norikra::Field.valid_type(:string)).to eql('string')
+      expect(Norikra::Field.valid_type('string')).to eql('string')
+
+      expect(Norikra::Field.valid_type('boolean')).to eql('boolean')
+      expect(Norikra::Field.valid_type('BOOLEAN')).to eql('boolean')
+      expect(Norikra::Field.valid_type('Int')).to eql('integer')
+      expect(Norikra::Field.valid_type('lonG')).to eql('integer')
+      expect(Norikra::Field.valid_type('FLOAT')).to eql('float')
+      expect(Norikra::Field.valid_type('Double')).to eql('float')
     end
 
     it 'raises ArgumentError for unknown type string' do
-      expect { Norikra::Field.valid_type?('foo') }.to raise_error()
+      expect { Norikra::Field.valid_type('foo') }.to raise_error(Norikra::ArgumentError)
     end
   end
 
@@ -103,7 +103,7 @@ describe Norikra::Field do
     end
 
     it 'value of type is normalized with .valid_type?' do
-      expect(Norikra::Field.new('foo', 'String').type).to eql(Norikra::Field.valid_type?('String'))
+      expect(Norikra::Field.new('foo', 'String').type).to eql(Norikra::Field.valid_type('String'))
     end
 
     it 'default value of optional is nil' do

data/spec/fieldset_spec.rb

@@ -10,7 +10,7 @@ describe Norikra::FieldSet do
     it 'accepts String as type' do
       set = Norikra::FieldSet.new({'x' => 'string', 'y' => 'long'})
       expect(set.fields['x'].type).to eql('string')
-      expect(set.fields['y'].type).to eql('long')
+      expect(set.fields['y'].type).to eql('integer')
     end
 
     it 'sets optional specification nil as defaults' do
@@ -31,15 +31,16 @@ describe Norikra::FieldSet do
 
     it 'sets summary as comma-separated labeled field-type string with sorted field order' do
       set = Norikra::FieldSet.new({'x' => 'string', 'y' => 'long'})
-      expect(set.summary).to eql('x:string,y:long')
+      expect(set.summary).to eql('x:string,y:integer')
 
       set = Norikra::FieldSet.new({'x' => 'string', 'y' => 'long', 'a' => 'Boolean'})
-      expect(set.summary).to eql('a:boolean,x:string,y:long')
+      expect(set.summary).to eql('a:boolean,x:string,y:integer')
     end
   end
 
   context 'initialized with some fields' do
     set = Norikra::FieldSet.new({'x' => 'string', 'y' => 'long', 'a' => 'Boolean'})
+    set2 = Norikra::FieldSet.new({'a' => 'string', 'b' => 'int', 'c' => 'float', 'd' => 'bool', 'e' => 'integer'})
 
     describe '#dup' do
       it 'make duplicated object with different internal instance' do
@@ -175,7 +176,7 @@ describe Norikra::FieldSet do
         x.update_summary
 
         expect(x.summary).not_to eql(oldsummary)
-        expect(x.summary).to eql('a:boolean,x:int,y:long')
+        expect(x.summary).to eql('a:boolean,x:integer,y:integer')
       end
     end
 
@@ -185,12 +186,12 @@ describe Norikra::FieldSet do
         expect(x.fields['a'].type).to eql('boolean')
         expect(x.fields['x'].type).to eql('string')
 
-        expect(x.fields['y'].type).to eql('long')
+        expect(x.fields['y'].type).to eql('integer')
         expect(x.fields['y'].optional).to be_nil
 
         x.update([Norikra::Field.new('y', 'int'), Norikra::Field.new('a','string')], false)
 
-        expect(x.fields['y'].type).to eql('int')
+        expect(x.fields['y'].type).to eql('integer')
         expect(x.fields['y'].optional).to eql(false)
 
         expect(x.fields['x'].type).to eql('string')
@@ -202,7 +203,7 @@ describe Norikra::FieldSet do
         expect(x.fields.size).to eql(3)
         x.update([Norikra::Field.new('z', 'string')], true)
         expect(x.fields.size).to eql(4)
-        expect(x.summary).to eql('a:boolean,x:string,y:long,z:string')
+        expect(x.summary).to eql('a:boolean,x:string,y:integer,z:string')
       end
     end
 
@@ -214,6 +215,16 @@ describe Norikra::FieldSet do
         expect(d['a']).to eql('boolean')
         expect(d['x']).to eql('string')
         expect(d['y']).to eql('long')
+
+        s = Norikra::FieldSet.new({'a' => 'string', 'b' => 'int', 'c' => 'float', 'd' => 'bool', 'e' => 'integer'})
+        d = s.definition
+        expect(d).to be_instance_of(Hash)
+        expect(d.size).to eql(5)
+        expect(d['a']).to eql('string')
+        expect(d['b']).to eql('long')
+        expect(d['c']).to eql('double')
+        expect(d['d']).to eql('boolean')
+        expect(d['e']).to eql('long')
       end
     end
 

data/spec/typedef_manager_spec.rb

@@ -51,7 +51,7 @@ describe Norikra::TypedefManager do
       expect(manager.typedefs['sample'].fields['a'].optional?).to be_false
       expect(manager.typedefs['sample'].fields['b'].type).to eql('string')
       expect(manager.typedefs['sample'].fields['b'].optional?).to be_false
-      expect(manager.typedefs['sample'].fields['c'].type).to eql('double')
+      expect(manager.typedefs['sample'].fields['c'].type).to eql('float')
       expect(manager.typedefs['sample'].fields['c'].optional?).to be_false
     end
 
@@ -63,7 +63,7 @@ describe Norikra::TypedefManager do
     describe '#reserve' do
       it 'does not fail' do
         manager.reserve('sample', 'x', 'long')
-        expect(manager.typedefs['sample'].fields['x'].type).to eql('long')
+        expect(manager.typedefs['sample'].fields['x'].type).to eql('integer')
         expect(manager.typedefs['sample'].fields['x'].optional?).to be_true
       end
     end
@@ -220,7 +220,7 @@ describe Norikra::TypedefManager do
       it 'returns fieldset instance with all required(non-optional) fields of target, and fields of query requires' do
         r = manager.generate_query_fieldset('sample', ['a', 'b','f'])
         expect(r.fields.size).to eql(4) # a,b,c,f
-        expect(r.summary).to eql('a:string,b:string,c:double,f:boolean')
+        expect(r.summary).to eql('a:string,b:string,c:float,f:boolean')
       end
     end
 
@@ -235,7 +235,7 @@ describe Norikra::TypedefManager do
         expect(r).to eql({
             a: {name: 'a', type: 'string', optional: false},
             b: {name: 'b', type: 'string', optional: false},
-            c: {name: 'c', type: 'double', optional: false},
+            c: {name: 'c', type: 'float', optional: false},
             z: {name: 'z', type: 'boolean', optional: true},
           })
 
@@ -243,8 +243,8 @@ describe Norikra::TypedefManager do
         expect(r).to eql({
             a: {name: 'a', type: 'string', optional: false},
             b: {name: 'b', type: 'string', optional: false},
-            c: {name: 'c', type: 'double', optional: false},
-            d: {name: 'd', type: 'double', optional: false},
+            c: {name: 'c', type: 'float', optional: false},
+            d: {name: 'd', type: 'float', optional: false},
           })
       end
     end

data/spec/typedef_spec.rb

@@ -36,7 +36,7 @@ describe Norikra::Typedef do
         expect(t.fields['k'].optional?).to be_true
 
         t.reserve('l', 'long', false)
-        expect(t.fields['l'].type).to eql('long')
+        expect(t.fields['l'].type).to eql('integer')
         expect(t.fields['l'].optional?).to be_false
       end
 
@@ -107,7 +107,7 @@ describe Norikra::Typedef do
       expect(t.fields['a'].type).to eql('string')
       expect(t.fields['a'].optional?).to be_false
 
-      expect(t.fields['b'].type).to eql('long')
+      expect(t.fields['b'].type).to eql('integer')
       expect(t.fields['b'].optional?).to be_false
     end
 
@@ -152,7 +152,7 @@ describe Norikra::Typedef do
 
         t.reserve('c', 'double', true)
         expect(t.fields.size).to eql(3)
-        expect(t.fields['c'].type).to eql('double')
+        expect(t.fields['c'].type).to eql('float')
         expect(t.fields['c'].optional?).to be_true
       end
     end
@@ -169,7 +169,7 @@ describe Norikra::Typedef do
           expect(t.consistent?(set)).to be_true
 
           set = Norikra::FieldSet.new({'a' => 'string', 'b' => 'int'})
-          expect(t.consistent?(set)).to be_false
+          expect(t.consistent?(set)).to be_true
 
           set = Norikra::FieldSet.new({'a' => 'string'})
           expect(t.consistent?(set)).to be_false
@@ -203,7 +203,7 @@ describe Norikra::Typedef do
     describe '#push' do
       it 'does not accepts fieldset which conflicts pre-defined fields' do
         t = Norikra::Typedef.new({'a' => 'string', 'b' => 'long'})
-        expect { t.push(:query, Norikra::FieldSet.new({'a'=>'string','b'=>'int'})) }.to raise_error(Norikra::ArgumentError)
+        expect { t.push(:query, Norikra::FieldSet.new({'a'=>'string','b'=>'float'})) }.to raise_error(Norikra::ArgumentError)
         expect { t.push(:data, Norikra::FieldSet.new({'a'=>'string'})) }.to raise_error(Norikra::ArgumentError)
       end
 
@@ -219,7 +219,7 @@ describe Norikra::Typedef do
         set_a = Norikra::FieldSet.new({'a'=>'string','b'=>'long','c'=>'double'})
         t.push(:data, set_a)
         expect(t.fields.size).to eql(3)
-        expect(t.fields['c'].type).to eql('double')
+        expect(t.fields['c'].type).to eql('float')
         expect(t.fields['c'].optional?).to be_true
 
         t.push(:query, Norikra::FieldSet.new({'a'=>'string','b'=>'long','d'=>'string'}))
@@ -420,10 +420,10 @@ describe Norikra::Typedef do
           expect(t.datafieldsets.include?(r)).to be_false
 
           expect(r.fields['a'].type).to eql('string')
-          expect(r.fields['b'].type).to eql('long')
+          expect(r.fields['b'].type).to eql('integer')
           expect(r.fields['c'].type).to eql('boolean')
-          expect(r.fields['d'].type).to eql('double')
-          expect(r.summary).to eql('a:string,b:long,c:boolean,d:double')
+          expect(r.fields['d'].type).to eql('float')
+          expect(r.summary).to eql('a:string,b:integer,c:boolean,d:float')
         end
 
         it 'returns fieldset that contains fields as string for unknowns for event with some unknown fields' do
@@ -433,10 +433,10 @@ describe Norikra::Typedef do
           expect(t.datafieldsets.include?(r)).to be_false
 
           expect(r.fields['a'].type).to eql('string')
-          expect(r.fields['b'].type).to eql('long')
+          expect(r.fields['b'].type).to eql('integer')
           expect(r.fields['c'].type).to eql('string')
           expect(r.fields['d'].type).to eql('string')
-          expect(r.summary).to eql('a:string,b:long,c:string,d:string')
+          expect(r.summary).to eql('a:string,b:integer,c:string,d:string')
         end
       end
 
@@ -461,10 +461,10 @@ describe Norikra::Typedef do
           expect(t.datafieldsets.include?(r)).to be_false
 
           expect(r.fields['a'].type).to eql('string')
-          expect(r.fields['b'].type).to eql('long')
+          expect(r.fields['b'].type).to eql('integer')
           expect(r.fields['c'].type).to eql('boolean')
-          expect(r.fields['d'].type).to eql('double')
-          expect(r.summary).to eql('a:string,b:long,c:boolean,d:double')
+          expect(r.fields['d'].type).to eql('float')
+          expect(r.summary).to eql('a:string,b:integer,c:boolean,d:float')
         end
 
         it 'returns fieldset that contains fields already known only for event with some unknown fields' do
@@ -474,15 +474,15 @@ describe Norikra::Typedef do
           expect(t.datafieldsets.include?(r1)).to be_false
 
           expect(r1.fields['a'].type).to eql('string')
-          expect(r1.fields['b'].type).to eql('long')
-          expect(r1.summary).to eql('a:string,b:long')
+          expect(r1.fields['b'].type).to eql('integer')
+          expect(r1.summary).to eql('a:string,b:integer')
 
           r2 = t.refer({'a'=>'hoge','b'=>'2000','c'=>'true','d'=>'3.14', 'e' => 'yeeeeeees!'}, true)
           expect(t.datafieldsets.include?(r2)).to be_false
 
           expect(r2.fields['a'].type).to eql('string')
-          expect(r2.fields['b'].type).to eql('long')
-          expect(r2.summary).to eql('a:string,b:long')
+          expect(r2.fields['b'].type).to eql('integer')
+          expect(r2.summary).to eql('a:string,b:integer')
         end
 
         it 'returns fieldset that contains fields already known or waiting fields for event with some unknown fields' do
@@ -493,17 +493,17 @@ describe Norikra::Typedef do
           expect(t.datafieldsets.include?(r1)).to be_false
 
           expect(r1.fields['a'].type).to eql('string')
-          expect(r1.fields['b'].type).to eql('long')
+          expect(r1.fields['b'].type).to eql('integer')
           expect(r1.fields['d'].type).to eql('string')
-          expect(r1.summary).to eql('a:string,b:long,d:string')
+          expect(r1.summary).to eql('a:string,b:integer,d:string')
 
           r2 = t.refer({'a'=>'hoge','b'=>'2000','c'=>'true','d'=>'3.14', 'e' => 'yeeeeeees!'}, true)
           expect(t.datafieldsets.include?(r2)).to be_false
 
           expect(r2.fields['a'].type).to eql('string')
-          expect(r2.fields['b'].type).to eql('long')
+          expect(r2.fields['b'].type).to eql('integer')
           expect(r1.fields['d'].type).to eql('string')
-          expect(r2.summary).to eql('a:string,b:long,d:string')
+          expect(r2.summary).to eql('a:string,b:integer,d:string')
         end
       end
     end
@@ -520,8 +520,8 @@ describe Norikra::Typedef do
         r = t.dump
         expect(r.keys.sort).to eql([:a, :b, :c, :d])
         expect(r[:a]).to eql({name: 'a', type: 'string', optional: false})
-        expect(r[:b]).to eql({name: 'b', type: 'long', optional: false})
-        expect(r[:c]).to eql({name: 'c', type: 'double', optional: true})
+        expect(r[:b]).to eql({name: 'b', type: 'integer', optional: false})
+        expect(r[:c]).to eql({name: 'c', type: 'float', optional: true})
         expect(r[:d]).to eql({name: 'd', type: 'string', optional: true})
 
         t2 = Norikra::Typedef.new(r)
@@ -540,8 +540,8 @@ describe Norikra::Typedef do
         r = t.dump
         expect(r.keys.sort).to eql([:a, :b, :c, :d, :e, :f])
         expect(r[:a]).to eql({name: 'a', type: 'string', optional: false})
-        expect(r[:b]).to eql({name: 'b', type: 'long', optional: false})
-        expect(r[:c]).to eql({name: 'c', type: 'double', optional: true})
+        expect(r[:b]).to eql({name: 'b', type: 'integer', optional: false})
+        expect(r[:c]).to eql({name: 'c', type: 'float', optional: true})
         expect(r[:d]).to eql({name: 'd', type: 'string', optional: true})
         expect(r[:e]).to eql({name: 'e', type: 'array', optional: true})
         expect(r[:f]).to eql({name: 'f', type: 'hash', optional: true})

metadata

@@ -2,14 +2,14 @@
 name: norikra
 version: !ruby/object:Gem::Version
   prerelease:
-  version: 0.1.0
+  version: 0.1.1
 platform: java
 authors:
 - TAGOMORI Satoshi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-11-01 00:00:00.000000000 Z
+date: 2013-11-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mizuno