sequel_pg 1.6.19 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2f3337f4ab6856e9ef371c69f82fa51c517afa49
-  data.tar.gz: 9361f0cb030decc088eab639448e383c76030d26
+  metadata.gz: a6a40cb36583e8f82e16b3346ba16ae6bfd76f6f
+  data.tar.gz: fe8457e463a51d1bc522cb87a14236e4dfee23c4
 SHA512:
-  metadata.gz: 43c2da7841e5d4b5a6e5bdd6f5d69fbb81e4cd8c6e7877f3bb3bbeafcf669d9a1fe22a2d57eef12bd1db17ab9a28d6a493a1a4261053c0250c23ec12cc6f679f
-  data.tar.gz: 203ffd82e356f006305245f6dece26d5638c41ce1d7dbd0053885d7c53bcafc7775fcfeb1deabc8391bec9d0f3c0fb773aa82b914d23c928b8c8c5cd57713a1d
+  metadata.gz: a098d4cc78fa9c3f13c7cdd7fd88fe83f222d42c36acf258eb757eb99d5015dd5c7b4db6052f0429fe6a49a75de6b3982133ff4c80daeb8b68428bebee86a5e5
+  data.tar.gz: cd9d11acc5c408fd3f3868fdc2c3364d477292e22891d52005057db456cfbce09aea65f8d02935482d42fa2d2cfd8cbb09f05ba6401dbfa38239919a23c08c64

data/CHANGELOG

@@ -1,3 +1,7 @@
+=== master
+
+* Override Dataset#as_hash instead of #to_hash if #as_hash is defined (jeremyevans)
+
 === 1.6.19 (2017-06-13)
 
 * Use PG::Error instead of PGError if available, avoiding deprecation warning on pg 0.21.0+ (jeremyevans)

data/README.rdoc

@@ -2,7 +2,7 @@
 
 sequel_pg overwrites the inner loop of the Sequel postgres adapter
 row fetching code with a C version.  The C version is significantly
-faster (2-6x) than the pure ruby version that Sequel uses by default.
+faster than the pure ruby version that Sequel uses by default.
 
 == Real world difference
 
@@ -11,61 +11,39 @@ selecting, but it should be noticeable whenever many rows are selected.
 Here's an example that shows the difference it makes on a couple of
 models:
 
-  $ irb -r model -r benchmark 
-  irb(main):001:0> Track.count
-  => 140854
-  irb(main):002:0> Album.count
-  => 5579
-  irb(main):003:0> puts Benchmark.measure{Track.each{}}
-   10.740000   0.190000  10.930000 ( 11.875343)
-  => nil
-  irb(main):004:0> puts Benchmark.measure{10.times{Album.each{}}}
-    7.920000   0.070000   7.990000 (  8.482130)
-  => nil
-  irb(main):005:0> require '/data/code/sequel_pg/ext/sequel_pg/sequel_pg'
-  => true
-  irb(main):006:0> puts Benchmark.measure{Track.each{}}
-    2.360000   0.400000   2.760000 (  3.723098)
-  => nil
-  irb(main):007:0> puts Benchmark.measure{10.times{Album.each{}}}
-    1.300000   0.190000   1.490000 (  2.001393)
-  => nil
-
-Here's an example that uses a modified version of swift's benchmarks
-(http://github.com/shanna/swift/tree/master/benchmarks/):
-  
-  benchmark         sys       user      total     real     rss
-  sequel #select    0.090000  2.020000  2.110000  2.246688 46.54m
-  sequel_pg #select 0.000000  0.250000  0.250000  0.361999  7.33m
-
-sequel_pg also has code to speed up the map, to_hash, to_hash_groups,
-select_hash, select_hash_groups, select_map, and select_order_map
-Dataset methods, which is on by default. It also has code to speed
-up the loading of model objects, which is off by default as it isn't
-fully compatible.  It doesn't handle overriding Model.call,
-Model#set_values, or Model#after_initialize, which may cause problems
-with the following plugins that ship with Sequel:
-
-* class_table_inheritance
-* force_encoding
-* serialization
-* single_table_inheritance
-* typecast_on_load
-* update_primary_key
-
-If you want to extract that last ounce of performance when loading
-model objects and you can live with the limitations, you can
-enable the model optimization via:
-
-  # All datasets
-  DB.optimize_model_load = true
-
-  # Specific dataset
-  Artist.dataset.optimize_model_load = true
+  Track.count # => 202261
+  Album.count # => 7264
+
+Without sequel_pg:
+
+  puts Benchmark.measure{Track.each{}}
+  # 3.400000   0.290000   3.690000 (  4.005150)
+  puts Benchmark.measure{10.times{Album.each{}}}
+  # 2.180000   0.120000   2.300000 (  2.479352)
+
+With sequel_pg:
+
+  puts Benchmark.measure{Track.each{}}
+  # 1.660000   0.260000   1.920000 (  2.287216)
+  puts Benchmark.measure{10.times{Album.each{}}}
+  # 0.960000   0.110000   1.070000 (  1.260913)
+
+sequel_pg also speeds up the following Dataset methods:
+
+* map
+* as_hash/to_hash
+* to_hash_groups,
+* select_hash
+* select_hash_groups
+* select_map
+* select_order_map
+
+Additionally, in most cases sequel_pg also speeds up the loading of
+model datasets by optimizing model instance creation.
 
 == Streaming
 
-If you are using PostgreSQL 9.2beta3 or higher on the client, then sequel_pg
+If you are using PostgreSQL 9.2+ on the client, then sequel_pg
 should enable streaming support.  This allows you to stream returned
 rows one at a time, instead of collecting the entire result set in
 memory (which is how PostgreSQL works by default).  You can check

data/ext/sequel_pg/sequel_pg.c

@@ -1,4 +1,4 @@
-#define SEQUEL_PG_VERSION_INTEGER 10619
+#define SEQUEL_PG_VERSION_INTEGER 10700
 
 #include <string.h>
 #include <stdio.h>

data/lib/sequel_pg/sequel_pg.rb

@@ -1,14 +1,25 @@
 # Add speedup for model class creation from dataset
 class Sequel::Postgres::Database
-  # Whether to optimize loads for all model datasets created from this dataset.
-  # Has certain limitations, see the README for details.
-  attr_accessor :optimize_model_load
+  def optimize_model_load=(v)
+    Sequel::Deprecation.deprecate("Database#optimize_model_load= is deprecated.  Optimized model loading is now enabled by default, and can only be disabled on a per-Dataset basis.")
+    v
+  end
+  def optimize_model_load
+    Sequel::Deprecation.deprecate("Database#optimize_model_load is deprecated.  Optimized model loading is now enabled by default, and can only be disabled on a per-Dataset basis.")
+    true
+  end
 end
 
-# Add faster versions of Dataset#map, #to_hash, #select_map, #select_order_map, and #select_hash
+# Add faster versions of Dataset#map, #as_hash, #to_hash_groups, #select_map, #select_order_map, and #select_hash
 class Sequel::Postgres::Dataset
-  # Set whether to enable optimized model loading for this dataset.
-  attr_writer :optimize_model_load
+  def optimize_model_load=(v)
+    Sequel::Deprecation.deprecate("Dataset#optimize_model_load= mutation method is deprecated.  Switch to using Dataset#with_optimize_model_load, which returns a modified dataset")
+    opts[:optimize_model_load] = v
+  end
+  def optimize_model_load
+    Sequel::Deprecation.deprecate("Dataset#optimize_model_load method is deprecated.  Optimized model loading is enabled by default.")
+    opts.has_key?(:optimize_model_load) ?  opts[:optimize_model_load] : true
+  end
 
   # In the case where an argument is given, use an optimized version.
   def map(sym=nil)
@@ -25,14 +36,13 @@ class Sequel::Postgres::Dataset
     end
   end
 
-  # If this dataset has turned model loading on or off, use the default value from
-  # the Database object.
-  def optimize_model_load
-    defined?(@optimize_model_load) ? @optimize_model_load : db.optimize_model_load
+  # Return a modified copy with the optimize_model_load setting changed.
+  def with_optimize_model_load(v)
+    clone(:optimize_model_load=>v)
   end
 
   # In the case where both arguments given, use an optimized version.
-  def to_hash(key_column, value_column = nil, opts = Sequel::OPTS)
+  def as_hash(key_column, value_column = nil, opts = Sequel::OPTS)
     if value_column && !opts[:hash]
       clone(:_sequel_pg_type=>:hash, :_sequel_pg_value=>[key_column, value_column]).fetch_rows(sql){|s| return s}
     elsif opts.empty?
@@ -42,6 +52,12 @@ class Sequel::Postgres::Dataset
     end
   end
 
+  unless Sequel::Dataset.method_defined?(:as_hash)
+    # Handle previous versions of Sequel that use to_hash instead of as_hash
+    alias to_hash as_hash
+    remove_method :as_hash
+  end
+
   # In the case where both arguments given, use an optimized version.
   def to_hash_groups(key_column, value_column = nil, opts = Sequel::OPTS)
     if value_column && !opts[:hash]
@@ -53,13 +69,15 @@ class Sequel::Postgres::Dataset
     end
   end
 
-  # If model loads are being optimized and this is a model load, use the optimized
-  # version.
-  def each
-    if (rp = row_proc) && optimize_model_load?
-      clone(:_sequel_pg_type=>:model, :_sequel_pg_value=>rp).fetch_rows(sql, &Proc.new)
-    else
-      super
+  if defined?(Sequel::Model::ClassMethods)
+    # If model loads are being optimized and this is a model load, use the optimized
+    # version.
+    def each
+      if optimize_model_load?
+        clone(:_sequel_pg_type=>:model, :_sequel_pg_value=>row_proc).fetch_rows(sql, &Proc.new)
+      else
+        super
+      end
     end
   end
     
@@ -81,10 +99,18 @@ class Sequel::Postgres::Dataset
 
   private
 
-  # The model load can only be optimized if it's for a model and it's not a graphed dataset
-  # or using a cursor.
-  def optimize_model_load?
-    (rp = row_proc).is_a?(Class) && (rp < Sequel::Model) && optimize_model_load && !opts[:use_cursor] && !opts[:graph]
+  if defined?(Sequel::Model::ClassMethods)
+    # The model load can only be optimized if it's for a model and it's not a graphed dataset
+    # or using a cursor.
+    def optimize_model_load?
+      (rp = row_proc) &&
+        rp.is_a?(Class) &&
+        rp < Sequel::Model &&
+        rp.method(:call).owner == Sequel::Model::ClassMethods &&
+        opts[:optimize_model_load] != false &&
+        !opts[:use_cursor] &&
+        !opts[:graph]
+    end
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel_pg
 version: !ruby/object:Gem::Version
-  version: 1.6.19
+  version: 1.7.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-13 00:00:00.000000000 Z
+date: 2017-06-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -41,7 +41,7 @@ dependencies:
 description: |
   sequel_pg overwrites the inner loop of the Sequel postgres
   adapter row fetching code with a C version.  The C version
-  is significantly faster (2-6x) than the pure ruby version
+  is significantly faster than the pure ruby version
   that Sequel uses by default.
 
   sequel_pg also offers optimized versions of some dataset