active_hll 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a357d4e04aad048c5abddf17021edde474073438414e6d85e3f48748ff1fc304
-  data.tar.gz: '03031590842b88853c7028e5a45174ff104f674ecf86e235f64fdb7120435c23'
+  metadata.gz: 49fecb9c7cb1cdcf399ce9ae00e9e637d9d3c0c3789ad02da9bef4e2977bc2f5
+  data.tar.gz: d02131c319a338575fc215397a95d153648bc6c5b390c453f67d0509b1a3ee6f
 SHA512:
-  metadata.gz: 2efc0fc07d80ae37f2063388151bfe3b0a7459d584a03b51661b1010f64b03d8e8b275e65664f859e77fb6c1fa48840ef3f7cae706f37c23afbefe6d358fe04f
-  data.tar.gz: 29c3beb46f85e6a58ed522a4503414b4cbb2f322c5563c26a07a38e2160d84058c3c79ace3dd17165f961b76d7313b8e5c4f906b52d52106fa8d5713bccb8ffc
+  metadata.gz: acc8c253b0d5ab708e73459ed35506e6d009f3c8f709c9f82a1b44ca77da2ac0a8431767f8d6a9d15faf5a17dbf20db1d7093008cad8e118979f1ffcf93b61ef
+  data.tar.gz: 1375c9ac1f6d6df024dfc0ccdf9304f1245a8d5510e8e69b34bf1d51fa49f6fb2bec7cf137476492c68d1b29f3344d947ba3b1cc26e762a53a46bf0c2681e7a1

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.2.1 (2024-10-07)
+
+- Fixed connection leasing for Active Record 7.2+
+
 ## 0.2.0 (2024-06-24)
 
 - Dropped support for Ruby < 3.1 and Active Record < 6.1

data/README.md

@@ -39,7 +39,7 @@ HLLs provide an approximate count of unique values (like unique visitors). By ro
 Create a table with an `hll` column
 
 ```ruby
-class CreateEventRollups < ActiveRecord::Migration[7.1]
+class CreateEventRollups < ActiveRecord::Migration[7.2]
   def change
     create_table :event_rollups do |t|
       t.date :time_bucket, index: {unique: true}

data/lib/active_hll/model.rb

@@ -20,65 +20,71 @@ module ActiveHll
       # experimental
       # doesn't work with non-default parameters
       def hll_generate(values)
-        parts = ["hll_empty()"]
+        Utils.with_connection(self) do |connection|
+          parts = ["hll_empty()"]
 
-        values.each do |value|
-          parts << Utils.hll_hash_sql(self, value)
-        end
+          values.each do |value|
+            parts << Utils.hll_hash_sql(connection, value)
+          end
 
-        result = connection.select_all("SELECT #{parts.join(" || ")}").rows[0][0]
-        ActiveHll::Type.new.deserialize(result)
+          result = connection.select_all("SELECT #{parts.join(" || ")}").rows[0][0]
+          ActiveHll::Type.new.deserialize(result)
+        end
       end
 
       def hll_add(attributes)
-        set_clauses =
-          attributes.map do |attribute, values|
-            values = [values] unless values.is_a?(Array)
-            return 0 if values.empty?
-
-            quoted_column = connection.quote_column_name(attribute)
-            # possibly fetch parameters for the column in the future
-            # for now, users should set a default value on the column
-            parts = ["COALESCE(#{quoted_column}, hll_empty())"]
-
-            values.each do |value|
-              parts << Utils.hll_hash_sql(self, value)
+        Utils.with_connection(self) do |connection|
+          set_clauses =
+            attributes.map do |attribute, values|
+              values = [values] unless values.is_a?(Array)
+              return 0 if values.empty?
+
+              quoted_column = connection.quote_column_name(attribute)
+              # possibly fetch parameters for the column in the future
+              # for now, users should set a default value on the column
+              parts = ["COALESCE(#{quoted_column}, hll_empty())"]
+
+              values.each do |value|
+                parts << Utils.hll_hash_sql(connection, value)
+              end
+
+              "#{quoted_column} = #{parts.join(" || ")}"
             end
 
-            "#{quoted_column} = #{parts.join(" || ")}"
-          end
-
-        update_all(set_clauses.join(", "))
+          update_all(set_clauses.join(", "))
+        end
       end
 
       # experimental
       def hll_upsert(attributes)
-        hll_columns, other_columns = attributes.keys.partition { |a| columns_hash[a.to_s]&.type == :hll }
+        Utils.with_connection(self) do |connection|
+          hll_columns, other_columns = attributes.keys.partition { |a| columns_hash[a.to_s]&.type == :hll }
 
-        # important! raise if column detection fails
-        if hll_columns.empty?
-          raise ArgumentError, "No hll columns"
-        end
+          # important! raise if column detection fails
+          if hll_columns.empty?
+            raise ArgumentError, "No hll columns"
+          end
 
-        quoted_table = connection.quote_table_name(table_name)
+          quoted_table = connection.quote_table_name(table_name)
 
-        quoted_hll_columns = hll_columns.map { |k| connection.quote_column_name(k) }
-        quoted_other_columns = other_columns.map { |k| connection.quote_column_name(k) }
-        quoted_columns = quoted_other_columns + quoted_hll_columns
+          quoted_hll_columns = hll_columns.map { |k| connection.quote_column_name(k) }
+          quoted_other_columns = other_columns.map { |k| connection.quote_column_name(k) }
+          quoted_columns = quoted_other_columns + quoted_hll_columns
 
-        hll_values =
-          hll_columns.map do |k|
-            vs = attributes[k]
-            vs = [vs] unless vs.is_a?(Array)
-            vs.map { |v| Utils.hll_hash_sql(self, v) }.join(" || ")
-          end
-        other_values = other_columns.map { |k| connection.quote(attributes[k]) }
+          hll_values =
+            hll_columns.map do |k|
+              vs = attributes[k]
+              vs = [vs] unless vs.is_a?(Array)
+              vs.map { |v| Utils.hll_hash_sql(connection, v) }.join(" || ")
+            end
+          other_values = other_columns.map { |k| connection.quote(attributes[k]) }
 
-        insert_values = other_values + hll_values.map { |v| "hll_empty()#{v.size > 0 ? " || #{v}" : ""}" }
-        update_values = quoted_hll_columns.zip(hll_values).map { |k, v| "#{k} = COALESCE(#{quoted_table}.#{k}, hll_empty())#{v.size > 0 ? " || #{v}" : ""}" }
+          insert_values = other_values + hll_values.map { |v| "hll_empty()#{v.size > 0 ? " || #{v}" : ""}" }
+          update_values = quoted_hll_columns.zip(hll_values).map { |k, v| "#{k} = COALESCE(#{quoted_table}.#{k}, hll_empty())#{v.size > 0 ? " || #{v}" : ""}" }
 
-        sql = "INSERT INTO #{quoted_table} (#{quoted_columns.join(", ")}) VALUES (#{insert_values.join(", ")}) ON CONFLICT (#{quoted_other_columns.join(", ")}) DO UPDATE SET #{update_values.join(", ")}"
-        connection.exec_insert(sql, "#{name} Upsert")
+          sql = "INSERT INTO #{quoted_table} (#{quoted_columns.join(", ")}) VALUES (#{insert_values.join(", ")}) ON CONFLICT (#{quoted_other_columns.join(", ")}) DO UPDATE SET #{update_values.join(", ")}"
+          connection.exec_insert(sql, "#{name} Upsert")
+        end
       end
     end
 
@@ -89,8 +95,10 @@ module ActiveHll
     end
 
     def hll_count(attribute)
-      quoted_column = self.class.connection.quote_column_name(attribute)
-      self.class.where(id: id).pluck("hll_cardinality(#{quoted_column})").first || 0.0
+      Utils.with_connection(self.class) do |connection|
+        quoted_column = connection.quote_column_name(attribute)
+        self.class.where(id: id).pluck("hll_cardinality(#{quoted_column})").first || 0.0
+      end
     end
   end
 end

data/lib/active_hll/utils.rb

@@ -1,7 +1,7 @@
 module ActiveHll
   module Utils
     class << self
-      def hll_hash_sql(klass, value)
+      def hll_hash_sql(connection, value)
         hash_function =
           case value
           when true, false
@@ -13,34 +13,40 @@ module ActiveHll
           else
             raise ArgumentError, "Unexpected type: #{value.class.name}"
           end
-        quoted_value = klass.connection.quote(value)
+        quoted_value = connection.quote(value)
         "#{hash_function}(#{quoted_value})"
       end
 
-      def hll_calculate(relation, operation, column, default_value:)
-        sql, relation, group_values = hll_calculate_sql(relation, operation, column)
-        result = relation.connection.select_all(sql)
+      def with_connection(relation, &block)
+        relation.connection_pool.with_connection(&block)
+      end
 
-        # 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] ? result.column_types[c].deserialize(untyped_row[i]) : untyped_row[i] })
-        end
+      def hll_calculate(relation, operation, column, default_value:)
+        Utils.with_connection(relation) do |connection|
+          sql, relation, group_values = hll_calculate_sql(relation, connection, operation, column)
+          result = connection.select_all(sql)
 
-        result =
-          if group_values.any?
-            Hash[rows.map { |r| [r.size == 2 ? r[0] : r[0..-2], r[-1]] }]
-          else
-            rows[0] && rows[0][0]
+          # 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] ? result.column_types[c].deserialize(untyped_row[i]) : untyped_row[i] })
           end
 
-        result = Groupdate.process_result(relation, result, default_value: default_value) if defined?(Groupdate.process_result)
+          result =
+            if group_values.any?
+              Hash[rows.map { |r| [r.size == 2 ? r[0] : r[0..-2], r[-1]] }]
+            else
+              rows[0] && rows[0][0]
+            end
+
+          result = Groupdate.process_result(relation, result, default_value: default_value) if defined?(Groupdate.process_result)
 
-        result
+          result
+        end
       end
 
-      def hll_calculate_sql(relation, operation, column)
+      def hll_calculate_sql(relation, connection, operation, column)
         # basic version of Active Record disallow_raw_sql!
         # symbol = column (safe), Arel node = SQL (safe), other = untrusted
         # matches table.column and column
@@ -54,7 +60,7 @@ module ActiveHll
         # column resolution
         node = relation.all.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
+        column = connection.visitor.accept(node, Arel::Collectors::SQLString.new).value
 
         group_values = relation.all.group_values
 

data/lib/active_hll/version.rb

@@ -1,3 +1,3 @@
 module ActiveHll
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_hll
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-06-24 00:00:00.000000000 Z
+date: 2024-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -60,7 +60,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
+rubygems_version: 3.5.16
 signing_key:
 specification_version: 4
 summary: HyperLogLog for Rails and Postgres