norikra-udf-percentile 0.0.1-java

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.ruby-version

@@ -0,0 +1 @@
+jruby-1.7.4

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in norikra-udf-percentile.gemspec
+gemspec

data/README.md

@@ -0,0 +1,29 @@
+# Norikra::Udf::Percentile
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'norikra-udf-percentile'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install norikra-udf-percentile
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,27 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = ["-c", "-f progress"] # '--format specdoc'
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+task :compile do
+  require 'rubygems'
+
+  jarname = FileList['norikra-udf-*.gemspec'].first.gsub(/\.gemspec$/, '.jar')
+
+  jarfiles = FileList['jar/**/*.jar'].select{|f| not f.end_with?('/' + jarname)}
+  jarfiles << Gem.find_files('esper-*.jar').first
+  classpath = "-classpath java:#{jarfiles.join(':')}"
+
+  FileList['java/**/*.java'].each do |fn|
+    sh "env LC_ALL=C javac #{classpath} #{fn}"
+  end
+  sh "env LC_ALL=C jar -cf jar/#{jarname} -C java ."
+end
+
+task :test => [:compile, :spec]
+task :default => :test
+
+task :all => [:compile, :spec, :build]

data/java/is/tagomor/norikra/udf/Percentile.java

@@ -0,0 +1,88 @@
+package is.tagomor.norikra.udf;
+
+import com.espertech.esper.epl.agg.aggregator.AggregationMethod;
+
+import java.util.ArrayList;
+import java.util.Random;
+
+public class Percentile implements AggregationMethod {
+  private static int initSize = 100000;
+
+  private ArrayList<Double> valueList;
+  private Integer target;
+
+  private Double last;
+
+  public Percentile() {
+    valueList = null;
+    last = null;
+  }
+
+  public long valueListSize() {
+    return valueList.size();
+  }
+
+  public Class getValueType() {
+    return Double.class;
+  }
+
+  public Double convertValue(Object v) {
+    if (v.getClass() == Double.class)
+      return (Double) v;
+    else if (v.getClass() == Float.class)
+      return new Double( ((Float) v).doubleValue() );
+    else if (v.getClass() == Integer.class)
+      return new Double( ((Integer) v).doubleValue() );
+    else if (v.getClass() == Long.class)
+      return new Double( ((Long) v).doubleValue() );
+    else
+      return new Double((String) v);
+  }    
+
+  public void enter(Object value) {
+    if (value == null)
+      return;
+
+    Object[] objs = (Object[]) value;
+    if (valueList == null) {
+      target = (Integer) objs[1];
+      valueList = new ArrayList<Double>(initSize);
+    }
+
+    Double d = convertValue(objs[0]);
+    synchronized (valueList) {
+      valueList.add(d);
+    }
+  }
+
+  public void leave(Object value) {
+    if (value == null)
+      return;
+
+    Object[] objs = (Object[]) value;
+    Double d = convertValue(objs[0]);
+    synchronized (valueList) {
+      valueList.remove(d);
+    }
+  }
+
+  public Object getValue() {
+    if (valueList.size() == 0)
+      return last;
+
+    Double[] values = (Double[]) valueList.toArray(new Double[]{});
+
+    // for thread safety
+    if (values.length == 0)
+      return last;
+
+    java.util.Arrays.sort(values);
+    int size = values.length;
+    last = values[size * target / 100];
+    return last;
+  }
+
+  public void clear() {
+    valueList = null;
+  }
+}

data/java/is/tagomor/norikra/udf/PercentileFactory.java

@@ -0,0 +1,53 @@
+package is.tagomor.norikra.udf;
+
+import com.espertech.esper.client.hook.AggregationFunctionFactory;
+import com.espertech.esper.epl.agg.service.AggregationValidationContext;
+import com.espertech.esper.epl.agg.aggregator.AggregationMethod;
+
+// import java.util.Map;
+
+public class PercentileFactory implements AggregationFunctionFactory {
+  public void setFunctionName(String functionName) {
+    // no action taken
+  }
+
+  /*
+    percentile(field_name, {percentile_specifications_array}[, samples])
+    ex: percentile(response_time, 50)
+   */
+  public void validate(AggregationValidationContext validationContext) {
+    if (validationContext.getParameterTypes().length != 2)
+      throw new IllegalArgumentException("percentile() accepts 2 arguments (fieldname,percentiles)");
+
+    Class first = validationContext.getParameterTypes()[0];
+    if (! (first == int.class || first == long.class || first == double.class || first == float.class ||
+           first == Integer.class || first == Long.class || first == Double.class || first == Float.class ||
+           first == String.class))
+      throw new IllegalArgumentException("percentile() first argument must be string or number, but " + first.toString());
+
+    Class second = validationContext.getParameterTypes()[1];
+    boolean f_second = validationContext.getIsConstantValue()[1];
+    if ((second != Integer.class && second != int.class) || !f_second)
+      throw new IllegalArgumentException("percentile() second argument must be Constant Integer");
+
+    if (validationContext.isDistinct())
+      throw new IllegalArgumentException("percentile() doesn't permit DISTINCT modifier");
+  }
+
+  /*
+    In order for the engine to validate the type returned by the aggregation function against
+    the types expected by enclosing expressions, the getValueType must return the result type
+    of any values produced by the aggregation function:
+   */
+  public Class getValueType() {
+    return Double.class;
+  }
+
+  /*
+    Finally the factory implementation must provide a newAggregator method that returns instances
+    of AggregationMethod. The engine invokes this method for each new aggregation state to be allocated.
+   */
+  public AggregationMethod newAggregator() {
+    return new Percentile();
+  }
+}

data/java/is/tagomor/norikra/udf/Percentiles.java

@@ -0,0 +1,94 @@
+package is.tagomor.norikra.udf;
+
+import com.espertech.esper.epl.agg.aggregator.AggregationMethod;
+
+import java.util.ArrayList;
+import java.util.Random;
+
+public class Percentiles implements AggregationMethod {
+  private static int initSize = 100000;
+
+  private ArrayList<Double> valueList;
+  private Integer[] targets;
+
+  private Double[] last;
+
+  public Percentiles() {
+    valueList = null;
+    last = null;
+  }
+
+  public long valueListSize() {
+    return valueList.size();
+  }
+
+  public Class getValueType() {
+    return Double[].class;
+  }
+
+  public Double convertValue(Object v) {
+    if (v.getClass() == Double.class)
+      return (Double) v;
+    else if (v.getClass() == Float.class)
+      return new Double( ((Float) v).doubleValue() );
+    else if (v.getClass() == Integer.class)
+      return new Double( ((Integer) v).doubleValue() );
+    else if (v.getClass() == Long.class)
+      return new Double( ((Long) v).doubleValue() );
+    else
+      return new Double((String) v);
+  }    
+
+  public void enter(Object value) {
+    if (value == null)
+      return;
+
+    Object[] objs = (Object[]) value;
+    if (valueList == null) {
+      targets = (Integer[]) objs[1];
+      valueList = new ArrayList<Double>(initSize);
+    }
+
+    Double d = convertValue(objs[0]);
+    synchronized (valueList) {
+      valueList.add(d);
+    }
+  }
+
+  public void leave(Object value) {
+    if (value == null)
+      return;
+
+    Object[] objs = (Object[]) value;
+    Double d = convertValue(objs[0]);
+    synchronized (valueList) {
+      valueList.remove(d);
+    }
+  }
+
+  public Object getValue() {
+    if (valueList.size() == 0)
+      return last;
+
+    ArrayList<Double> percentiles = new ArrayList<Double>(targets.length);
+    Double[] values = (Double[]) valueList.toArray(new Double[]{});
+
+    // for thread safety
+    if (values.length == 0)
+      return last;
+
+    java.util.Arrays.sort(values);
+    int size = values.length;
+
+    for (int i = 0 ; i < targets.length ; i += 1) {
+      percentiles.add(values[size * targets[i] / 100]);
+    }
+
+    last = (Double[]) percentiles.toArray(new Double[]{});
+    return last;
+  }
+
+  public void clear() {
+    valueList = null;
+  }
+}

data/java/is/tagomor/norikra/udf/PercentilesFactory.java

@@ -0,0 +1,53 @@
+package is.tagomor.norikra.udf;
+
+import com.espertech.esper.client.hook.AggregationFunctionFactory;
+import com.espertech.esper.epl.agg.service.AggregationValidationContext;
+import com.espertech.esper.epl.agg.aggregator.AggregationMethod;
+
+// import java.util.Map;
+
+public class PercentilesFactory implements AggregationFunctionFactory {
+  public void setFunctionName(String functionName) {
+    // no action taken
+  }
+
+  /*
+    percentiles(field_name, {percentile_specifications_array}[, samples])
+    ex: percentiles(response_time, {50,90,95,98,99})
+   */
+  public void validate(AggregationValidationContext validationContext) {
+    if (validationContext.getParameterTypes().length != 2)
+      throw new IllegalArgumentException("percentiles() accepts 2 arguments (fieldname,percentiles)");
+
+    Class first = validationContext.getParameterTypes()[0];
+    if (! (first == int.class || first == long.class || first == double.class || first == float.class ||
+           first == Integer.class || first == Long.class || first == Double.class || first == Float.class ||
+           first == String.class))
+      throw new IllegalArgumentException("percentiles() first argument must be string or number, but " + first.toString());
+
+    Class second = validationContext.getParameterTypes()[1];
+    boolean f_second = validationContext.getIsConstantValue()[1];
+    if (second != Integer[].class || !f_second)
+      throw new IllegalArgumentException("percentiles() second argument must be Constant Array of Integer");
+
+    if (validationContext.isDistinct())
+      throw new IllegalArgumentException("percentiles() doesn't permit DISTINCT modifier");
+  }
+
+  /*
+    In order for the engine to validate the type returned by the aggregation function against
+    the types expected by enclosing expressions, the getValueType must return the result type
+    of any values produced by the aggregation function:
+   */
+  public Class getValueType() {
+    return Double[].class;
+  }
+
+  /*
+    Finally the factory implementation must provide a newAggregator method that returns instances
+    of AggregationMethod. The engine invokes this method for each new aggregation state to be allocated.
+   */
+  public AggregationMethod newAggregator() {
+    return new Percentiles();
+  }
+}

data/lib/norikra/udf/percentile.rb

@@ -0,0 +1,23 @@
+require 'norikra/udf'
+
+module Norikra
+  module UDF
+    class Percentile < Norikra::UDF::AggregationSingle
+      def self.init
+        require 'norikra-udf-percentile.jar'
+      end
+      def definition
+        ["percentile", "is.tagomor.norikra.udf.PercentileFactory"]
+      end
+    end
+
+    class Percentiles < Norikra::UDF::AggregationSingle
+      def self.init
+        require 'norikra-udf-percentile.jar'
+      end
+      def definition
+        ["percentiles", "is.tagomor.norikra.udf.PercentilesFactory"]
+      end
+    end
+  end
+end

data/norikra-udf-percentile.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+
+Gem::Specification.new do |spec|
+  spec.name          = "norikra-udf-percentile"
+  spec.version       = "0.0.1"
+  spec.authors       = ["TAGOMORI Satoshi"]
+  spec.email         = ["tagomoris@gmail.com"]
+  spec.description   = %q{This plugin adds functions named percentile/percentiles, which calculate percentile for specified fields}
+  spec.summary       = %q{Norikra UDF percentile() and percentiles()}
+  spec.homepage      = "https://github.com/tagomoris/norikra-udf-percentile"
+  spec.license       = "GPLv2"
+  spec.platform      = "java"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib", "jar"]
+
+  spec.add_runtime_dependency "norikra", ">= 0.0.9"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/spec/percentile_spec.rb

@@ -0,0 +1,64 @@
+require 'norikra/udf_spec_helper'
+
+include Norikra::UDFSpecHelper
+
+require 'norikra/udf/percentile'
+
+describe Norikra::UDF::Percentile do
+  f = udf_function(
+    Norikra::UDF::Percentile,
+    :valueType => java.lang.Double,
+    :parameters => [
+      [java.lang.String, false],
+      [java.lang.Integer, true, 50],
+    ]
+  )
+
+  it 'returns Double values' do
+    expect(f.getValueType).to eql(java.lang.Double.java_class)
+  end
+
+  it 'returns 9 values as percentiles, and reflect for leve()' do
+    (0...100).each do |i|
+      f._call(:enter, [i.to_s, 50.to_java(:Integer)].to_java)
+    end
+
+    r = f.getValue
+    expect(r).to eql(50.0)
+
+    (0...50).each do |i|
+      f._call(:leave, [i.to_s, 50.to_java(:Integer)].to_java)
+    end
+
+    expect(f.instance_eval{ @func.valueListSize }).to eql(50)
+
+    r = f.getValue
+    expect(r).to eql(75.0)
+  end
+
+  f2 = udf_function(
+    Norikra::UDF::Percentile,
+    :valueType => java.lang.Double,
+    :parameters => [
+      [java.lang.Integer, false],
+      [java.lang.Integer, true, 90],
+    ]
+  )
+  it 'returns 5 values as percentiles, and returns same value after all values leaving' do
+    (0...2000).to_a.shuffle.each do |i|
+      f2._call(:enter, [i, 90.to_java(:Integer)].to_java)
+    end
+
+    expect(f2.instance_eval{ @func.valueListSize }).to eql(2000)
+
+    r = f2.getValue
+    expect(r).to eql(1800.0)
+
+    (0...2000).to_a.shuffle.each do |i|
+      f2._call(:leave, [i, 90.to_java(:Integer)].to_java)
+    end
+
+    r2 = f2.getValue
+    expect(r2).to eql(r)
+  end
+end

data/spec/percentiles_spec.rb

@@ -0,0 +1,82 @@
+require 'norikra/udf_spec_helper'
+
+include Norikra::UDFSpecHelper
+
+require 'norikra/udf/percentile'
+
+describe Norikra::UDF::Percentiles do
+  f = udf_function(
+    Norikra::UDF::Percentiles,
+    :valueType => java.lang.Double[],
+    :parameters => [
+      [java.lang.String, false],
+      [java.lang.Integer[], true, [10,20,30,40,50,60,70,80,90].to_java(:Integer)].to_java,
+    ]
+  )
+
+  it 'returns Double[] values' do
+    expect(f.getValueType).to eql(java.lang.Double[].java_class)
+  end
+
+  it 'returns 9 values as percentiles, and reflect for leve()' do
+    (0...100).each do |i|
+      f._call(:enter, [i.to_s, [10,20,30,40,50,60,70,80,90].to_java(:Integer)].to_java)
+    end
+
+    r = f.getValue
+    expect(r.size).to eql(9)
+    expect(r[0]).to eql(10.0)
+    expect(r[1]).to eql(20.0)
+    expect(r[2]).to eql(30.0)
+    expect(r[3]).to eql(40.0)
+    expect(r[4]).to eql(50.0)
+    expect(r[5]).to eql(60.0)
+    expect(r[6]).to eql(70.0)
+    expect(r[7]).to eql(80.0)
+    expect(r[8]).to eql(90.0)
+
+    (0...50).each do |i|
+      f._call(:leave, [i.to_s, [10,20,30,40,50,60,70,80,90].to_java(:Integer)].to_java)
+    end
+
+    expect(f.instance_eval{ @func.valueListSize }).to eql(50)
+
+    r = f.getValue
+    expect(r.size).to eql(9)
+    expect(r[0]).to eql(55.0)
+    expect(r[1]).to eql(60.0)
+    expect(r[2]).to eql(65.0)
+    expect(r[3]).to eql(70.0)
+    expect(r[4]).to eql(75.0)
+    expect(r[5]).to eql(80.0)
+    expect(r[6]).to eql(85.0)
+    expect(r[7]).to eql(90.0)
+    expect(r[8]).to eql(95.0)
+  end
+
+  f2 = udf_function(
+    Norikra::UDF::Percentiles,
+    :valueType => java.lang.Double[],
+    :parameters => [
+      [java.lang.Integer, false],
+      [java.lang.Integer[], true, [50,90,95,98,99].to_java(:Integer)].to_java,
+    ]
+  )
+  it 'returns 5 values as percentiles, and returns same value after all values leaving' do
+    (0...2000).to_a.shuffle.each do |i|
+      f2._call(:enter, [i, [50,90,95,98,99].to_java(:Integer), 100].to_java)
+    end
+
+    expect(f2.instance_eval{ @func.valueListSize }).to eql(2000)
+
+    r = f2.getValue
+    expect(r.size).to eql(5)
+
+    (0...2000).to_a.shuffle.each do |i|
+      f2._call(:leave, [i, [50,90,95,98,99].to_java(:Integer), 100].to_java)
+    end
+
+    r2 = f2.getValue
+    expect(r2).to eql(r)
+  end
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: norikra-udf-percentile
+version: !ruby/object:Gem::Version
+  prerelease:
+  version: 0.0.1
+platform: java
+authors:
+- TAGOMORI Satoshi
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2013-08-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: norikra
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.9
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.9
+    none: false
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: bundler
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    none: false
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rake
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rspec
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  prerelease: false
+  type: :development
+description: This plugin adds functions named percentile/percentiles, which calculate percentile for specified fields
+email:
+- tagomoris@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .ruby-version
+- Gemfile
+- README.md
+- Rakefile
+- jar/norikra-udf-percentile.jar
+- java/is/tagomor/norikra/udf/Percentile.class
+- java/is/tagomor/norikra/udf/Percentile.java
+- java/is/tagomor/norikra/udf/PercentileFactory.class
+- java/is/tagomor/norikra/udf/PercentileFactory.java
+- java/is/tagomor/norikra/udf/Percentiles.class
+- java/is/tagomor/norikra/udf/Percentiles.java
+- java/is/tagomor/norikra/udf/PercentilesFactory.class
+- java/is/tagomor/norikra/udf/PercentilesFactory.java
+- lib/norikra/udf/percentile.rb
+- norikra-udf-percentile.gemspec
+- spec/percentile_spec.rb
+- spec/percentiles_spec.rb
+homepage: https://github.com/tagomoris/norikra-udf-percentile
+licenses:
+- GPLv2
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+- jar
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+requirements: []
+rubyforge_project:
+rubygems_version: 1.8.24
+signing_key:
+specification_version: 3
+summary: Norikra UDF percentile() and percentiles()
+test_files:
+- spec/percentile_spec.rb
+- spec/percentiles_spec.rb