relation_to_struct 1.4.1 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5589ae299275b2682dcaabc687188d08bb39ce36
-  data.tar.gz: 519b3a9f0a019ec9473ecd23f791c36f0c4ac831
+  metadata.gz: b36da83b17102b8a6f19d1bd7b55ba8486d2bd9b
+  data.tar.gz: 3693bc1c95c15877d4e58a66b5700210e4861ff6
 SHA512:
-  metadata.gz: 7c112e6889dbb37a656f864e6d799b0df41b35f7a6cead1f0faf16de990233fd3bc379402d3ef3f6011bd0b420c3e9a01b8439da5e7252774192ce11a62d5ca9
-  data.tar.gz: e08956b50dd9c1835c5ec133a4238f4c0ac5e1e499f0f28e862a651800dbd3ec5336a8aeecb674e527101321255d6ebc2eabe2a977fa30bf31229f6e956f06ec
+  metadata.gz: a1a43b34975434afd52f51ddd8ab1f3ba135e976248865a67ffc4ddc7fcfb6d9423c25168f4228c538b6c617d9d5a85559ebeebc99ff460f3a3df368cf973c8b
+  data.tar.gz: 7ea17f61be34643cadeaa7377b0ca481ef574d32c2327a8986bf915a4b6d5e0bdae260477547d51f0ee49c197032f1471d8f28d5e25a386fea0906ffa7f27081

data/README.md

@@ -69,6 +69,32 @@ eos
 ActiveRecord::Base.tuple_from_sql(sql) # => [id, name]
 ```
 
+```
+sql = <<-eos
+  SELECT 1
+eos
+
+ActiveRecord::Base.run_sql(sql) # => <no defined result>
+```
+
+```
+sql = <<-eos
+  INSERT INTO foos(bar) VALUES(1)
+eos
+
+ActiveRecord::Base.run_sql(sql) # => <number of rows modified>
+```
+
+## Project Policy/Philosophy
+
+Executing database queries should be clearly explicit in your application code. Implicit queries (e.g., in association accesses) is an anti-pattern that results in problems like N+1 querying.
+
+### Query Caching
+
+Query caching is another problem downstream from implicit querying. Because queries are happening "behind the scenes" and there's no obvious place for explicit result caching, it seems desirable to cache at the query level. But this approach applies caching at the wrong level: your application code must still expend all of the effort required to build a SQL query and (potentially) interpret results. Caching queries automatically (as Rails does by default in a web request) can easily lead to gotchas because the framework has no way of determining when caching is actually safe (both from a business logic and query contents perspective).
+
+For this reason, **all methods added to `ActiveRecord::Base` explicitly disable query caching**. Rails defaults are respected, however, on extensions to `ActiveRecord::Relation` since it's not as obvious that those queries are intended to be explicit.
+
 ## Contributing
 
 1. Fork it ( https://github.com/jcoleman/relation_to_struct/fork )

data/lib/relation_to_struct/active_record_base_extension.rb

@@ -8,7 +8,9 @@ module RelationToStruct::ActiveRecordBaseExtension
 
     def structs_from_sql(struct_class, sql, binds=[])
       sanitized_sql = _sanitize_sql_for_relation_to_struct(sql)
-      result = connection.select_all(sanitized_sql, "Structs SQL Load", binds)
+      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'
@@ -31,13 +33,17 @@ module RelationToStruct::ActiveRecordBaseExtension
 
     def pluck_from_sql(sql, binds=[])
       sanitized_sql = _sanitize_sql_for_relation_to_struct(sql)
-      result = connection.select_all(sanitized_sql, "Pluck SQL Load", binds)
+      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 = connection.select_all(sanitized_sql, "Value SQL Load", binds)
+      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()
@@ -53,7 +59,9 @@ module RelationToStruct::ActiveRecordBaseExtension
 
     def tuple_from_sql(sql, binds=[])
       sanitized_sql = _sanitize_sql_for_relation_to_struct(sql)
-      result = connection.select_all(sanitized_sql, "Value SQL Load", binds)
+      result = ActiveRecord::Base.uncached do
+        connection.select_all(sanitized_sql, "Value SQL Load", binds)
+      end
       values = result.cast_values()
 
       case values.size
@@ -65,6 +73,15 @@ module RelationToStruct::ActiveRecordBaseExtension
         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
   end
 end
 

data/lib/relation_to_struct/version.rb

@@ -1,3 +1,3 @@
 module RelationToStruct
-  VERSION = "1.4.1"
+  VERSION = "1.5.0"
 end

data/spec/active_record_base_spec.rb

@@ -16,6 +16,20 @@ describe ActiveRecord::Base do
       sql = "SELECT 1 * 23, 25"
       expect(ActiveRecord::Base.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 = ActiveRecord::Base.pluck_from_sql(sql)
+        value_2 = ActiveRecord::Base.pluck_from_sql(sql)
+      end
+
+      expect(value_1).not_to eq(value_2)
+    end
   end
 
   describe "#value_from_sql" do
@@ -54,6 +68,20 @@ describe ActiveRecord::Base do
         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 = ActiveRecord::Base.value_from_sql(sql)
+        value_2 = ActiveRecord::Base.value_from_sql(sql)
+      end
+
+      expect(value_1).not_to eq(value_2)
+    end
   end
 
   describe "#tuple_from_sql" do
@@ -112,6 +140,20 @@ describe ActiveRecord::Base do
         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 = ActiveRecord::Base.tuple_from_sql(sql)
+        value_2 = ActiveRecord::Base.tuple_from_sql(sql)
+      end
+
+      expect(value_1).not_to eq(value_2)
+    end
   end
 
   describe "#structs_from_sql" do
@@ -169,5 +211,58 @@ describe ActiveRecord::Base do
         ActiveRecord::Base.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 = ActiveRecord::Base.structs_from_sql(test_struct, sql)
+        value_2 = ActiveRecord::Base.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 { ActiveRecord::Base.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 { ActiveRecord::Base.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"
+      ActiveRecord::Base.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(ActiveRecord::Base.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
+          ActiveRecord::Base.run_sql("INSERT INTO economic_schools(name) VALUES ('Chicago')")
+          ActiveRecord::Base.run_sql("INSERT INTO economic_schools(name) VALUES ('Distributism')")
+        end.to change { ActiveRecord::Base.value_from_sql("SELECT COUNT(*) FROM economic_schools") }.by(2)
+      end
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: relation_to_struct
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 1.5.0
 platform: ruby
 authors:
 - James Coleman