active_median 0.2.3 → 0.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 47d759f5155e0a9687eeb845cf25a65daae5fe2a475bed1dcc071b742413b8c4
-  data.tar.gz: 9eb8b10f9ff8526adcea04beb4fa68fb11e61b544f11413925280c5d37f10e2b
+  metadata.gz: 9f779fe5268fc1347cd94c47fc55a3322a3d52282539d0ca7d001e37c405f9a1
+  data.tar.gz: 37d6b834f1857f6119d3ec7969d422f7d4f3fcbeaa1645d8bc0f8a3f10824c04
 SHA512:
-  metadata.gz: af49d340ff2b1298d1706381a7879ac3666e9077a56607c2d8809b132f93eef3eb8beb9996aa7599157a3d900ad3951e606413cb936f23d045115d8baead0121
-  data.tar.gz: ed82a1e318b79372aace81c56d2ca9bd9c59f373be5795f2e595fc8a60c7a7bdd9f9191e5a46069c4ea7405347e3057abb3c1ad6ae794a252cdce6de7f5411b6
+  metadata.gz: 180be6b9f59bc10e2bc0e708f4d8ad01d4d3d7a27d95707162ef45c4478ff858d6b6b5a2f598b6c411bf0e4942f02f0a13a642b04746e79fb124c2c6d70e58cb
+  data.tar.gz: db9436660c4fa4e2bdd80af101dbc8723f46781f17eeeecc57e8015a2510d9429bce6f38f93b210c82b2499b3dae787df26c1d0e898280af98174738a29eb984

data/CHANGELOG.md

@@ -1,19 +1,39 @@
-## 0.2.3
+## 0.2.8 (2021-01-16)
+
+- Fixed bug with removing order
+
+## 0.2.7 (2021-01-16)
+
+- Fixed error with order
+
+## 0.2.6 (2020-12-18)
+
+- Fixed error with certain column types for Active Record 6.1
+
+## 0.2.5 (2020-09-07)
+
+- Added warning for non-attribute argument
+
+## 0.2.4 (2020-03-12)
+
+- Added `percentile` method
+
+## 0.2.3 (2019-09-03)
 
 - Added support for Mongoid
-- Dropped support for Rails 4.2
+- Dropped support for Active Record 4.2
 
-## 0.2.2
+## 0.2.2 (2018-10-29)
 
 - Added support for MySQL with udf_infusion
 - Added support for SQL Server and Redshift
 
-## 0.2.1
+## 0.2.1 (2018-10-15)
 
 - Added support for arrays and hashes
 - Added compatibility with Groupdate 4
 
-## 0.2.0
+## 0.2.0 (2018-10-15)
 
 - Added support for MariaDB 10.3.3+ and SQLite
 - Use `PERCENTILE_CONT` for 4x performance increase
@@ -22,23 +42,23 @@ Breaking
 
 - Dropped support for Postgres < 9.4
 
-## 0.1.4
+## 0.1.4 (2016-12-03)
 
 - Added `drop_function` method
 
-## 0.1.3
+## 0.1.3 (2016-03-22)
 
-- Added support for ActiveRecord 5.0
+- Added support for Active Record 5.0
 
-## 0.1.2
+## 0.1.2 (2014-12-27)
 
-- Added support for ActiveRecord 4.2
+- Added support for Active Record 4.2
 
-## 0.1.1
+## 0.1.1 (2014-08-12)
 
 - 10x faster median
 - Added tests
 
-## 0.1.0
+## 0.1.0 (2014-03-13)
 
 - First release

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2013-2019 Andrew Kane
+Copyright (c) 2013-2021 Andrew Kane
 
 MIT License
 

data/README.md

@@ -1,6 +1,6 @@
 # ActiveMedian
 
-Median for Active Record, Mongoid, arrays, and hashes
+Median and percentile for Active Record, Mongoid, arrays, and hashes
 
 Supports:
 
@@ -8,10 +8,11 @@ Supports:
 - MariaDB 10.3.3+
 - MySQL and SQL (with extensions)
 - SQL Server 2012+
+- MongoDB 2.1+
 
 :fire: Uses native functions for blazing performance
 
-[![Build Status](https://travis-ci.org/ankane/active_median.svg)](https://travis-ci.org/ankane/active_median)
+[![Build Status](https://github.com/ankane/active_median/workflows/build/badge.svg?branch=master)](https://github.com/ankane/active_median/actions)
 
 ## Getting Started
 
@@ -25,26 +26,22 @@ For MySQL and SQLite, also follow [these instructions](#additional-instructions)
 
 ## Models
 
-```ruby
-Item.median(:price)
-```
-
-Works with grouping, too.
+Median
 
 ```ruby
-Order.group(:store_id).median(:total)
+Item.median(:price)
 ```
 
-## Arrays and Hashes
+Percentile
 
 ```ruby
-[1, 2, 3].median
+Request.percentile(:response_time, 0.95)
 ```
 
-You can also pass a block.
+Works with grouping, too
 
 ```ruby
-{a: 1, b: 2, c: 3}.median { |k, v| v }
+Order.group(:store_id).median(:total)
 ```
 
 ## User Input
@@ -60,6 +57,26 @@ raise "Unpermitted column" unless ["column_a", "column_b"].include?(column)
 User.median(column)
 ```
 
+## Arrays and Hashes
+
+Median
+
+```ruby
+[1, 2, 3].median
+```
+
+Percentile
+
+```ruby
+[1, 2, 3].percentile(0.95)
+```
+
+You can also pass a block
+
+```ruby
+{a: 1, b: 2, c: 3}.median { |k, v| v }
+```
+
 ## Additional Instructions
 
 ### MySQL
@@ -106,3 +123,13 @@ Everyone is encouraged to help improve this project. Here are a few ways you can
 - Fix bugs and [submit pull requests](https://github.com/ankane/active_median/pulls)
 - Write, clarify, or fix documentation
 - Suggest or add new features
+
+To get started with development and testing:
+
+```sh
+git clone https://github.com/ankane/active_median.git
+cd active_median
+createdb active_median_test
+bundle install
+bundle exec rake test
+```

data/lib/active_median/enumerable.rb

@@ -6,9 +6,35 @@ module Enumerable
       elsif !block && respond_to?(:with_scope)
         with_scope(self) { klass.median(*args) }
       else
+        raise ArgumentError, "wrong number of arguments (given #{args.size}, expected 0)" if args.any?
+        percentile(0.5, &block)
+      end
+    end
+  end
+
+  unless method_defined?(:percentile)
+    def percentile(*args, &block)
+      if !block && respond_to?(:scoping)
+        scoping { @klass.percentile(*args) }
+      elsif !block && respond_to?(:with_scope)
+        with_scope(self) { klass.percentile(*args) }
+      else
+        raise ArgumentError, "wrong number of arguments (given #{args.size}, expected 1)" if args.size != 1
+
+        percentile = args[0].to_f
+        raise ArgumentError, "percentile is not between 0 and 1" if percentile < 0 || percentile > 1
+
+        # uses C=1 variant, like percentile_cont
+        # https://en.wikipedia.org/wiki/Percentile#The_linear_interpolation_between_closest_ranks_method
         sorted = map(&block).sort
-        len = sorted.length
-        (sorted[(len - 1) / 2] + sorted[len / 2]) / 2.0
+        x = percentile * (sorted.size - 1)
+        r = x % 1
+        i = x.floor
+        if i == sorted.size - 1
+          sorted[-1]
+        else
+          sorted[i] + r * (sorted[i + 1] - sorted[i])
+        end
       end
     end
   end

data/lib/active_median/model.rb

@@ -1,6 +1,28 @@
 module ActiveMedian
   module Model
     def median(column)
+      percentile(column, 0.5)
+    end
+
+    def percentile(column, percentile)
+      percentile = percentile.to_f
+      raise ArgumentError, "percentile is not between 0 and 1" if percentile < 0 || percentile > 1
+
+      # basic version of Active Record disallow_raw_sql!
+      # symbol = column (safe), Arel node = SQL (safe), other = untrusted
+      # matches table.column and column
+      unless column.is_a?(Symbol) || column.is_a?(Arel::Nodes::SqlLiteral) || /\A\w+(\.\w+)?\z/i.match(column.to_s)
+        warn "[active_median] Non-attribute argument: #{column}. Use Arel.sql() for known-safe values. This will raise an error in ActiveMedian 0.3.0"
+      end
+
+      # column resolution
+      node = relation.send(:arel_columns, [column]).first
+      node = Arel::Nodes::SqlLiteral.new(node) if node.is_a?(String)
+      column = relation.connection.visitor.accept(node, Arel::Collectors::SQLString.new).value
+
+      # prevent SQL injection
+      percentile = connection.quote(percentile)
+
       group_values = all.group_values
 
       relation =
@@ -15,32 +37,45 @@ module ActiveMedian
               over = "PARTITION BY #{group_values.join(", ")}"
             end
 
-            select(*group_values, "PERCENTILE_CONT(0.50) WITHIN GROUP (ORDER BY #{column}) OVER (#{over})").unscope(:group)
+            select(*group_values, "PERCENTILE_CONT(#{percentile}) WITHIN GROUP (ORDER BY #{column}) OVER (#{over})").unscope(:group)
           else
             # if mysql gets native function, check (and memoize) version first
-            select(*group_values, "PERCENTILE_CONT(#{column}, 0.50)")
+            select(*group_values, "PERCENTILE_CONT(#{column}, #{percentile})")
           end
         when /sqlserver/i
           if group_values.any?
             over = "PARTITION BY #{group_values.join(", ")}"
           end
 
-          select(*group_values, "PERCENTILE_CONT(0.50) WITHIN GROUP (ORDER BY #{column}) OVER (#{over})").unscope(:group)
+          select(*group_values, "PERCENTILE_CONT(#{percentile}) WITHIN GROUP (ORDER BY #{column}) OVER (#{over})").unscope(:group)
         when /sqlite/i
-          select(*group_values, "MEDIAN(#{column})")
+          case percentile.to_f
+          when 0
+            select(*group_values, "MIN(#{column})")
+          when 0.5
+            select(*group_values, "MEDIAN(#{column})")
+          when 1
+            select(*group_values, "MAX(#{column})")
+          else
+            # LOWER_QUARTILE and UPPER_QUARTILE use different calculation than 0.25 and 0.75
+            raise "SQLite only supports 0, 0.5, and 1 percentiles"
+          end
         when /postg/i, /redshift/i # postgis too
-          select(*group_values, "PERCENTILE_CONT(0.50) WITHIN GROUP (ORDER BY #{column})")
+          select(*group_values, "PERCENTILE_CONT(#{percentile}) WITHIN GROUP (ORDER BY #{column})")
         else
           raise "Connection adapter not supported: #{connection.adapter_name}"
         end
 
+      # same as average
+      relation = relation.unscope(:order).distinct!(false) if group_values.empty?
+
       result = connection.select_all(relation.to_sql)
 
       # typecast
       rows = []
       columns = result.columns
       result.rows.each do |untyped_row|
-        rows << (result.column_types.empty? ? untyped_row : columns.each_with_index.map { |c, i| untyped_row[i] ? result.column_types[c].send(:cast_value, untyped_row[i]) : untyped_row[i] })
+        rows << (result.column_types.empty? ? untyped_row : columns.each_with_index.map { |c, i| untyped_row[i] && result.column_types[c] ? result.column_types[c].send(:cast_value, untyped_row[i]) : untyped_row[i] })
       end
 
       result =

data/lib/active_median/mongoid.rb

@@ -1,21 +1,30 @@
 module ActiveMedian
   module Mongoid
-    # https://www.compose.com/articles/mongo-metrics-finding-a-happy-median/
     def median(column)
+      percentile(column, 0.5)
+    end
+
+    # https://www.compose.com/articles/mongo-metrics-finding-a-happy-median/
+    def percentile(column, percentile)
+      percentile = percentile.to_f
+      raise ArgumentError, "percentile is not between 0 and 1" if percentile < 0 || percentile > 1
+
       relation =
         all
-        .group(_id: nil, count: {"$sum" => 1}, values: {"$push" => "$#{column}"})
-        .unwind("$values")
-        .asc(:values)
-        .project(count: {"$subtract" => ["$count", 1]}, values: 1)
-        .project(count: 1, values: 1, midpoint: {"$divide" => ["$count", 2]})
-        .project(count: 1, values: 1, midpoint: 1, high: {"$ceil" => "$midpoint"}, low: {"$floor" => "$midpoint"})
-        .group(_id: nil, values: {"$push" => "$values"}, high: {"$avg" => "$high"}, low: {"$avg" => "$low"})
-        .project(beginValue: {"$arrayElemAt" => ["$values", "$high"]}, endValue: {"$arrayElemAt" => ["$values", "$low"]})
-        .project(median: {"$avg" => ["$beginValue", "$endValue"]})
+        .asc(column)
+        .group(_id: nil, values: {"$push" => "$#{column}"}, count: {"$sum" => 1})
+        .project(values: 1, count: {"$subtract" => ["$count", 1]})
+        .project(values: 1, count: 1, x: {"$multiply" => ["$count", percentile]})
+        .project(values: 1, count: 1, r: {"$mod" => ["$x", 1]}, i: {"$floor" => "$x"})
+        .project(values: 1, count: 1, r: 1, i: 1, i2: {"$add" => ["$i", 1]})
+        .project(values: 1, count: 1, r: 1, i: 1, i2: {"$min" => ["$i2", "$count"]})
+        .project(r: 1, beginValue: {"$arrayElemAt" => ["$values", "$i"]}, endValue: {"$arrayElemAt" => ["$values", "$i2"]})
+        .project(r: 1, beginValue: 1, result: {"$subtract" => ["$endValue", "$beginValue"]})
+        .project(beginValue: 1, result: {"$multiply" => ["$result", "$r"]})
+        .project(result: {"$add" => ["$beginValue", "$result"]})
 
       res = collection.aggregate(relation.pipeline).first
-      res ? res["median"] : nil
+      res ? res["result"] : nil
     end
   end
 end

data/lib/active_median/version.rb

@@ -1,3 +1,3 @@
 module ActiveMedian
-  VERSION = "0.2.3"
+  VERSION = "0.2.8"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_median
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.8
 platform: ruby
 authors:
 - Andrew Kane
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-09-04 00:00:00.000000000 Z
+date: 2021-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -108,7 +108,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description:
 email: andrew@chartkick.com
 executables: []
 extensions: []
@@ -126,7 +126,7 @@ homepage: https://github.com/ankane/active_median
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -141,8 +141,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
-summary: Median for Active Record, Mongoid, arrays, and hashes
+summary: Median and percentile for Active Record, Mongoid, arrays, and hashes
 test_files: []