relation_to_struct 1.5.1 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 7c0ecf02a9aab05f81adc8704ad9fcf8b71ec339859ba9ef491e0a2ea9eb75e9
-  data.tar.gz: 2cd15cd6e481026b2b9294d621db0ea7d257168a5288e4316cc9735d09b3bcfd
+SHA1:
+  metadata.gz: d1ffdbfc2950c798cd223660370ca62ee6a8128b
+  data.tar.gz: 246947abe7a8f85d6c2558a3b33a0b027547ada4
 SHA512:
-  metadata.gz: b38fe58cf3b14d889789526b85dab4afa03e29c7d3825d39c92ae5dcac23eeea2dab7cdacf95a320438996d8cd8e4b434ea4b0d40198f5eab3539d157b76a54c
-  data.tar.gz: f3c565ca306f0120c9081626c4a9ee07569f68a75382b2409d0714fb603ae9010f4903789a50568482469a97bf96fb64e16044252bd6fb249261fab2baf4f4bc
+  metadata.gz: 25ef491ea1f470beea129c8e1d5f92308773092ef470afaadedd56ec9046ad1950d4192e1e61efa816966ecf0dc5eafe40c23bc33ed0572424d0c82368d6cbdf
+  data.tar.gz: 8a8f2eebe3192ae4d3947a309adfd476e903af1bc754496d1f53f03d8040afb8ad12f12f640a4f69dcc54179b015b02399a19b2d712420b0dabed21fff561c2a

data/README.md

@@ -36,6 +36,8 @@ relation.to_structs(UserPostsSummary) # => array of structs
 
 ### From raw SQL
 
+Note: In order to provide a consistent user experience regardless of the abstraction level used by your code, all of the following methods are available on both `ActiveRecord::Base` and `ActiveRecord::Base.connection`.
+
 ```
 UserPostsSummary = Struct.new(:user_name, :post_count)
 sql = <<-eos

data/lib/relation_to_struct.rb

@@ -1,4 +1,5 @@
 require "relation_to_struct/version"
+require "relation_to_struct/active_record_connection_adapter_extension"
 require "relation_to_struct/active_record_base_extension"
 require "relation_to_struct/active_record_relation_extension"
 

data/lib/relation_to_struct/active_record_base_extension.rb

@@ -1,88 +1,18 @@
 module RelationToStruct::ActiveRecordBaseExtension
-  extend ::ActiveSupport::Concern
-
   module ClassMethods
     def _sanitize_sql_for_relation_to_struct(sql)
       sanitized_sql = ActiveRecord::VERSION::MAJOR >= 5 ? sanitize_sql(sql) : sanitize_sql(sql, nil)
     end
 
-    def structs_from_sql(struct_class, sql, binds=[])
-      sanitized_sql = _sanitize_sql_for_relation_to_struct(sql)
-      result = ActiveRecord::Base.uncached do
-        connection.select_all(sanitized_sql, "Structs SQL Load", binds)
-      end
-
-      if result.columns.size != result.columns.uniq.size
-        raise ArgumentError, 'Expected column names to be unique'
-      end
-
-      if result.columns != struct_class.members.collect(&:to_s)
-        raise ArgumentError, 'Expected column names (and their order) to match struct attribute names'
-      end
-
-      if result.columns.size == 1
-        result.cast_values().map do |tuple|
-          struct_class.new(tuple)
-        end
-      else
-        result.cast_values().map do |tuple|
-          struct_class.new(*tuple)
-        end
-      end
-    end
-
-    def pluck_from_sql(sql, binds=[])
-      sanitized_sql = _sanitize_sql_for_relation_to_struct(sql)
-      result = ActiveRecord::Base.uncached do
-        connection.select_all(sanitized_sql, "Pluck SQL Load", binds)
-      end
-      result.cast_values()
-    end
-
-    def value_from_sql(sql, binds=[])
-      sanitized_sql = _sanitize_sql_for_relation_to_struct(sql)
-      result = ActiveRecord::Base.uncached do
-        connection.select_all(sanitized_sql, "Value SQL Load", binds)
-      end
-      raise ArgumentError, 'Expected exactly one column to be selected' unless result.columns.size == 1
-
-      values = result.cast_values()
-      case values.size
-      when 0
-        nil
-      when 1
-        values[0]
-      else
-        raise ArgumentError, 'Expected only a single result to be returned'
-      end
-    end
-
-    def tuple_from_sql(sql, binds=[])
-      sanitized_sql = _sanitize_sql_for_relation_to_struct(sql)
-      result = ActiveRecord::Base.uncached do
-        connection.select_all(sanitized_sql, "Value SQL Load", binds)
-      end
-      values = result.cast_values()
-
-      case values.size
-      when 0
-        nil
-      when 1
-        result.columns.size == 1 ? values : values[0]
-      else
-        raise ArgumentError, 'Expected only a single result to be returned'
-      end
-    end
-
-    def run_sql(sql, binds=[])
-      sanitized_sql = _sanitize_sql_for_relation_to_struct(sql)
-      # We don't need to build a result set unnecessarily; using
-      # interface this also ensures we're clearing the result set
-      # for manually memory managed object (e.g., when using the
-      # PostgreSQL adaptor).
-      connection.exec_update(sanitized_sql, "Run SQL", binds)
-    end
+    delegate(
+      :structs_from_sql,
+      :pluck_from_sql,
+      :value_from_sql,
+      :tuple_from_sql,
+      :run_sql,
+      :to => :connection
+    )
   end
 end
 
-::ActiveRecord::Base.send(:include, RelationToStruct::ActiveRecordBaseExtension)
+::ActiveRecord::Base.singleton_class.send(:prepend, RelationToStruct::ActiveRecordBaseExtension::ClassMethods)

data/lib/relation_to_struct/active_record_connection_adapter_extension.rb

@@ -0,0 +1,80 @@
+module RelationToStruct::ActiveRecordConnectionAdapterExtension
+  def structs_from_sql(struct_class, sql, binds=[])
+    sanitized_sql = ActiveRecord::Base._sanitize_sql_for_relation_to_struct(sql)
+    result = ActiveRecord::Base.uncached do
+      select_all(sanitized_sql, "Structs SQL Load", binds)
+    end
+
+    if result.columns.size != result.columns.uniq.size
+      raise ArgumentError, 'Expected column names to be unique'
+    end
+
+    if result.columns != struct_class.members.collect(&:to_s)
+      raise ArgumentError, 'Expected column names (and their order) to match struct attribute names'
+    end
+
+    if result.columns.size == 1
+      result.cast_values().map do |tuple|
+        struct_class.new(tuple)
+      end
+    else
+      result.cast_values().map do |tuple|
+        struct_class.new(*tuple)
+      end
+    end
+  end
+
+  def pluck_from_sql(sql, binds=[])
+    sanitized_sql = ActiveRecord::Base._sanitize_sql_for_relation_to_struct(sql)
+    result = ActiveRecord::Base.uncached do
+      select_all(sanitized_sql, "Pluck SQL Load", binds)
+    end
+    result.cast_values()
+  end
+
+  def value_from_sql(sql, binds=[])
+    sanitized_sql = ActiveRecord::Base._sanitize_sql_for_relation_to_struct(sql)
+    result = ActiveRecord::Base.uncached do
+      select_all(sanitized_sql, "Value SQL Load", binds)
+    end
+    raise ArgumentError, 'Expected exactly one column to be selected' unless result.columns.size == 1
+
+    values = result.cast_values()
+    case values.size
+    when 0
+      nil
+    when 1
+      values[0]
+    else
+      raise ArgumentError, 'Expected only a single result to be returned'
+    end
+  end
+
+  def tuple_from_sql(sql, binds=[])
+    sanitized_sql = ActiveRecord::Base._sanitize_sql_for_relation_to_struct(sql)
+    result = ActiveRecord::Base.uncached do
+      select_all(sanitized_sql, "Value SQL Load", binds)
+    end
+    values = result.cast_values()
+
+    case values.size
+    when 0
+      nil
+    when 1
+      result.columns.size == 1 ? values : values[0]
+    else
+      raise ArgumentError, 'Expected only a single result to be returned'
+    end
+  end
+
+  def run_sql(sql, binds=[])
+    sanitized_sql = ActiveRecord::Base._sanitize_sql_for_relation_to_struct(sql)
+    # We don't need to build a result set unnecessarily; using
+    # interface this also ensures we're clearing the result set
+    # for manually memory managed object (e.g., when using the
+    # PostgreSQL adaptor).
+    exec_update(sanitized_sql, "Run SQL", binds)
+  end
+end
+
+::ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:prepend, RelationToStruct::ActiveRecordConnectionAdapterExtension)

data/lib/relation_to_struct/active_record_relation_extension.rb

@@ -1,6 +1,4 @@
 module RelationToStruct::ActiveRecordRelationExtension
-  extend ::ActiveSupport::Concern
-
   def to_structs(struct_class)
     raise ArgumentError, 'Expected select_values to be present' unless self.select_values.present?
 
@@ -37,4 +35,4 @@ module RelationToStruct::ActiveRecordRelationExtension
   end
 end
 
-::ActiveRecord::Relation.send(:include, RelationToStruct::ActiveRecordRelationExtension)
+::ActiveRecord::Relation.send(:prepend, RelationToStruct::ActiveRecordRelationExtension)

data/lib/relation_to_struct/version.rb

@@ -1,3 +1,3 @@
 module RelationToStruct
-  VERSION = "1.5.1"
+  VERSION = "1.6.0"
 end

data/spec/active_record_connection_adapter_spec.rb

@@ -0,0 +1,270 @@
+require 'spec_helper'
+
+describe ActiveRecord::ConnectionAdapters::AbstractAdapter do
+  before(:each) do
+    Economist.delete_all
+    EconomicSchool.delete_all
+  end
+
+  let(:connection) { ActiveRecord::Base.connection }
+
+  describe "#pluck_from_sql" do
+    it 'allows plucking with SQL directly' do
+      sql = "SELECT 1 * 23"
+      expect(connection.pluck_from_sql(sql)).to eq([23])
+    end
+
+    it 'allows plucking multiple columns with SQL directly' do
+      sql = "SELECT 1 * 23, 25"
+      expect(connection.pluck_from_sql(sql)).to eq([[23, 25]])
+    end
+
+    it 'bypasses the statement cache' do
+      sql = "SELECT random()"
+      value_1 = value_2 = nil
+
+      # Simulate a standard web request in Rails, since
+      # Rails enabled caching by default.
+      ActiveRecord::Base.cache do
+        value_1 = connection.pluck_from_sql(sql)
+        value_2 = connection.pluck_from_sql(sql)
+      end
+
+      expect(value_1).not_to eq(value_2)
+    end
+  end
+
+  describe "#value_from_sql" do
+    it 'allows selecting a value with SQL directly' do
+      sql = "SELECT 1 * 23"
+      expect(connection.value_from_sql(sql)).to eq(23)
+    end
+
+    it 'raises an error when multiple rows are selected' do
+      expect do
+        sql = "SELECT * FROM (VALUES (1), (2)) t"
+        connection.value_from_sql(sql)
+      end.to raise_error(ArgumentError, 'Expected only a single result to be returned')
+    end
+
+    it 'raises an error when multiple columns are selected' do
+      expect do
+        sql = "SELECT 1, 2"
+        connection.value_from_sql(sql)
+      end.to raise_error(ArgumentError, 'Expected exactly one column to be selected')
+    end
+
+    it 'supports binds' do
+      sql = ["SELECT 1 * ?", 5]
+      expect(connection.value_from_sql(sql)).to eq(5)
+    end
+
+    it 'supports arrays' do
+      if active_record_supports_arrays?
+        Economist.create!(name: 'F.A. Hayek')
+        Economist.create!(name: 'Ludwig von Mises')
+
+        result = connection.value_from_sql('SELECT ARRAY_AGG(name ORDER BY id) AS names FROM economists')
+        expect(result).to eq(['F.A. Hayek', 'Ludwig von Mises'])
+      else
+        skip "DB selection doesn't support ARRAY[]"
+      end
+    end
+
+    it 'bypasses the statement cache' do
+      sql = "SELECT random()"
+      value_1 = value_2 = nil
+
+      # Simulate a standard web request in Rails, since
+      # Rails enabled caching by default.
+      ActiveRecord::Base.cache do
+        value_1 = connection.value_from_sql(sql)
+        value_2 = connection.value_from_sql(sql)
+      end
+
+      expect(value_1).not_to eq(value_2)
+    end
+  end
+
+  describe "#tuple_from_sql" do
+    it 'allows selecting one value with SQL directly' do
+      sql = "SELECT 1"
+      expect(connection.tuple_from_sql(sql)).to eq([1])
+    end
+
+    it 'allows selecting multiple values with SQL directly' do
+      sql = "SELECT 1, 23"
+      expect(connection.tuple_from_sql(sql)).to eq([1, 23])
+    end
+
+    it 'raises an error when multiple rows are selected' do
+      expect do
+        sql = "SELECT * FROM (VALUES (1, 3), (2, 4)) t"
+        connection.tuple_from_sql(sql)
+      end.to raise_error(ArgumentError, 'Expected only a single result to be returned')
+    end
+
+    it 'supports binds' do
+      sql = ["SELECT ?, ?", 5, 6]
+      expect(connection.tuple_from_sql(sql)).to eq([5, 6])
+    end
+
+    it 'supports a single array' do
+      if active_record_supports_arrays?
+        Economist.create!(name: 'F.A. Hayek')
+        Economist.create!(name: 'Ludwig von Mises')
+
+        result = connection.tuple_from_sql(<<-SQL)
+          SELECT ARRAY_AGG(name ORDER BY id) AS names
+          FROM economists
+        SQL
+        expected_names = ['F.A. Hayek', 'Ludwig von Mises']
+        expect(result).to eq([expected_names])
+      else
+        skip "DB selection doesn't support ARRAY[]"
+      end
+    end
+
+    it 'supports multiple arrays' do
+      if active_record_supports_arrays?
+        Economist.create!(name: 'F.A. Hayek')
+        Economist.create!(name: 'Ludwig von Mises')
+
+        result = connection.tuple_from_sql(<<-SQL)
+          SELECT
+            ARRAY_AGG(name ORDER BY id) AS names,
+            ARRAY_AGG(CHAR_LENGTH(name) ORDER BY id) AS lengths
+          FROM economists
+        SQL
+        expected_names = ['F.A. Hayek', 'Ludwig von Mises']
+        expect(result).to eq([expected_names, expected_names.map(&:size)])
+      else
+        skip "DB selection doesn't support ARRAY[]"
+      end
+    end
+
+    it 'bypasses the statement cache' do
+      sql = "SELECT random()"
+      value_1 = value_2 = nil
+
+      # Simulate a standard web request in Rails, since
+      # Rails enabled caching by default.
+      ActiveRecord::Base.cache do
+        value_1 = connection.tuple_from_sql(sql)
+        value_2 = connection.tuple_from_sql(sql)
+      end
+
+      expect(value_1).not_to eq(value_2)
+    end
+  end
+
+  describe "#structs_from_sql" do
+    it 'ActiveRecord::Base should respond to :structs_from_sql' do
+      expect(connection.respond_to?(:structs_from_sql)).to eq(true)
+    end
+
+    it 'allows querying with SQL directly' do
+      test_struct = Struct.new(:number)
+      sql = "SELECT 1 * 23 AS number"
+      expect(connection.structs_from_sql(test_struct, sql)).to eq([test_struct.new(23)])
+    end
+
+    it 'properly casts a single array column' do
+      if active_record_supports_arrays?
+        Economist.create!(name: 'F.A. Hayek')
+        Economist.create!(name: 'Ludwig von Mises')
+
+        test_struct = Struct.new(:names)
+        structs_results = connection.structs_from_sql(test_struct, 'SELECT ARRAY_AGG(name ORDER BY id) AS names FROM economists')
+        expect(structs_results.first.names).to eq(['F.A. Hayek', 'Ludwig von Mises'])
+      else
+        skip "DB selection doesn't support ARRAY[]"
+      end
+    end
+
+    it 'raises an error when column count does not match struct size' do
+      expect do
+        test_struct = Struct.new(:id, :name, :extra_field)
+        connection.structs_from_sql(test_struct, 'SELECT id, name FROM economists')
+      end.to raise_error(ArgumentError, 'Expected column names (and their order) to match struct attribute names')
+    end
+
+    it 'raises an error when column names are not unique' do
+      expect do
+        test_struct = Struct.new(:id, :id2)
+        connection.structs_from_sql(test_struct, 'SELECT id, id FROM economists')
+      end.to raise_error(ArgumentError, 'Expected column names to be unique')
+    end
+
+    it 'raises an error when the column names do not match the struct attribute names' do
+      Economist.create!(name: 'F.A. Hayek')
+      expect do
+        test_struct = Struct.new(:value_a, :value_b)
+        connection.structs_from_sql(test_struct, 'SELECT 1 AS value_a, 2 AS value_b FROM economists')
+      end.not_to raise_error
+
+      expect do
+        test_struct = Struct.new(:value_a, :value_b)
+        connection.structs_from_sql(test_struct, 'SELECT 1 AS value_b, 2 AS value_a FROM economists')
+      end.to raise_error(ArgumentError, 'Expected column names (and their order) to match struct attribute names')
+
+      expect do
+        test_struct = Struct.new(:value_a, :value_b)
+        connection.structs_from_sql(test_struct, 'SELECT 1 AS value_a, 2 AS value_c FROM economists')
+      end.to raise_error(ArgumentError, 'Expected column names (and their order) to match struct attribute names')
+    end
+
+    it 'bypasses the statement cache' do
+      test_struct = Struct.new(:r)
+      sql = "SELECT random() AS r"
+      value_1 = value_2 = nil
+
+      # Simulate a standard web request in Rails, since
+      # Rails enabled caching by default.
+      ActiveRecord::Base.cache do
+        value_1 = connection.structs_from_sql(test_struct, sql)
+        value_2 = connection.structs_from_sql(test_struct, sql)
+      end
+
+      expect(value_1).not_to eq(value_2)
+    end
+  end
+
+  describe "#run_sql" do
+    it 'executes the provided SQL' do
+      sql = "INSERT INTO economic_schools(name) VALUES ('Chicago')"
+      expect do
+        ActiveRecord::Base.run_sql(sql)
+      end.to change { connection.value_from_sql("SELECT COUNT(*) FROM economic_schools") }.by(1)
+    end
+
+    it 'supports binds' do
+      sql = ["INSERT INTO economic_schools(name) VALUES (?)", "Chicago"]
+      expect do
+        ActiveRecord::Base.run_sql(sql)
+      end.to change { connection.value_from_sql("SELECT COUNT(*) FROM economic_schools") }.by(1)
+    end
+
+    it 'uses the exec_update API to avoid turning things in an ActiveRecord::Result' do
+      expect(ActiveRecord::Base.connection).to receive(:exec_update).exactly(:once)
+      sql = "SELECT 1"
+      connection.run_sql(sql)
+    end
+
+    it 'returns the number of rows modified for an INSERT' do
+      sql = "INSERT INTO economic_schools(name) VALUES ('Chicago'), ('Distributism')"
+      expect(connection.run_sql(sql)).to eq(2)
+    end
+
+    it 'bypasses the statement cache' do
+      # Simulate a standard web request in Rails, since
+      # Rails enabled caching by default.
+      ActiveRecord::Base.cache do
+        expect do
+          connection.run_sql("INSERT INTO economic_schools(name) VALUES ('Chicago')")
+          connection.run_sql("INSERT INTO economic_schools(name) VALUES ('Distributism')")
+        end.to change { connection.value_from_sql("SELECT COUNT(*) FROM economic_schools") }.by(2)
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: relation_to_struct
 version: !ruby/object:Gem::Version
-  version: 1.5.1
+  version: 1.6.0
 platform: ruby
 authors:
 - James Coleman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-11-04 00:00:00.000000000 Z
+date: 2020-02-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: appraisal
@@ -168,10 +168,12 @@ files:
 - gemfiles/rails_6_0.gemfile
 - lib/relation_to_struct.rb
 - lib/relation_to_struct/active_record_base_extension.rb
+- lib/relation_to_struct/active_record_connection_adapter_extension.rb
 - lib/relation_to_struct/active_record_relation_extension.rb
 - lib/relation_to_struct/version.rb
 - relation_to_struct.gemspec
 - spec/active_record_base_spec.rb
+- spec/active_record_connection_adapter_spec.rb
 - spec/active_record_helper/economic_school.rb
 - spec/active_record_helper/economist.rb
 - spec/active_record_helper/schema.rb
@@ -198,12 +200,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubyforge_project: 
+rubygems_version: 2.5.2.3
 signing_key: 
 specification_version: 4
 summary: Return struct results from ActiveRecord relation queries
 test_files:
 - spec/active_record_base_spec.rb
+- spec/active_record_connection_adapter_spec.rb
 - spec/active_record_helper/economic_school.rb
 - spec/active_record_helper/economist.rb
 - spec/active_record_helper/schema.rb