sequel 5.54.0 → 5.55.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3baaadc192f621e371699d654e998661db242d11385b328e5298ebfa7ce97d53
-  data.tar.gz: b6595670122d1ec5bbaccabef8d3af58a08f4d6edb6ffa782e34a1152d971143
+  metadata.gz: dfed01eed8d575d13963be4568c8935f82c47a59b2be32d382439d50153f032d
+  data.tar.gz: 9ac182c00cdc1f54c26626005f990c5e0a05eebaae3b3c5b88bac0fcd770cd8e
 SHA512:
-  metadata.gz: ebf7ff5a43c42d769a1f35e7c90f32c24e7776cde36c17c1800a4603b8173066bb90864b0644dfb6402221e1ed37ea36a9b026e6ab07e3086ed208eb6fb58d67
-  data.tar.gz: 82b525b77248038a08e2b247ae8de8028a1d4f67f332b267bd81f9d4087ebd900fcb58b1a7b9b82b20e3b93a00dd3a665d03dbe583ba94866c43663993c7436b
+  metadata.gz: c9aceee8528a749c541f74eeb07610b520e4342ac8d11abda3222fd0d760e2ff2a16e1b08b7931f5d24cb0ae9fced020ef695798ffac6c4b4af15508e8927468
+  data.tar.gz: 19e40f6386373bdbba07b5a65faf5ffc99a5693e81b0eaeaf1abffc9b07cc29c2688ea658629f633eb36a3427f74857cab28216d18cfb208cca97a75ea10788e

data/CHANGELOG

@@ -1,3 +1,11 @@
+=== 5.55.0 (2022-04-01)
+
+* Support :setup_regexp_function Database option in the sqlite adapter to allow the use of regexps when querying (jeremyevans)
+
+* Add auto_restrict_eager_graph plugin for automatically disallow eager_graph with associations needing but lacking graph options (jeremyevans)
+
+* Fix placeholder literalizer optimization for dataset aggregate methods on a model dataset (belousovAV) (#1847, #1848)
+
 === 5.54.0 (2022-03-01)
 
 * Add enum plugin for treating columns as enums in a model (jeremyevans) (#1839)

data/doc/opening_databases.rdoc

@@ -383,6 +383,9 @@ The following additional options are supported:
 
 :readonly :: open database in read-only mode
 :timeout :: the busy timeout to use in milliseconds (default: 5000).
+:setup_regexp_function :: Whether to setup a REGEXP function in the underlying SQLite3::Database object. Doing so
+                          allows you to use regexp support in dataset expressions.  Note that this creates a new
+                          Regexp object per call to the function, so it is not an efficient implementation.
 
 Note that SQLite memory databases are restricted to a single connection by
 default.  This is because SQLite does not allow multiple connections to

data/doc/querying.rdoc

@@ -357,7 +357,9 @@ For ranges, Sequel uses a pair of inequality statements:
   # SELECT * FROM artists WHERE ((id >= 1) AND (id < 5))
 
 Finally, for regexps, Sequel uses an SQL regular expression.  Note that this
-is probably only supported on PostgreSQL and MySQL.
+is only supported by default on PostgreSQL and MySQL.  It can also be supported
+on SQLite when using the sqlite adapter with the :setup_regexp_function
+Database option.
 
   Artist.where(name: /JM$/)
   # SELECT * FROM artists WHERE (name ~ 'JM$')

data/doc/release_notes/5.55.0.txt

@@ -0,0 +1,21 @@
+= New Features
+
+* An auto_restrict_eager_graph plugin has been added for automatically
+  disallowing the use of eager_graph with associations using blocks but
+  lacking graph_* options.  This can prevent potentionally invalid usage,
+  as the restrictions added by the block are not used by eager_graph.
+
+* The sqlite adapter now supports the :setup_regexp_function
+  Database option. This option will define a REGEXP function in the
+  database that will allow regexp support in queries, such as:
+
+    DB[:table].where(column: /(some|pattern)/)
+
+  Note that this creates a Ruby Regexp object per column value tested,
+  so it isn't the most optimal approach. 
+
+= Other Improvements
+
+* Calling dataset aggregate methods such as #max on a model dataset now
+  works correctly. Previously, it could fail if called enough times to
+  optimize using a placeholder literalizer.

data/doc/sql.rdoc

@@ -528,7 +528,7 @@ Inverting the LIKE operator works like other inversions:
 
   ~Sequel.like(:name, 'A%') # ("name" NOT LIKE 'A%' ESCAPE '\')
 
-Sequel also supports SQL regular expressions on MySQL and PostgreSQL.  You can use these by passing a Ruby regular expression to +like+ or +ilike+, or by making the regular expression a hash value:
+Sequel also supports SQL regular expressions on MySQL and PostgreSQL (and SQLite when using the sqlite adapter with the :setup_regexp_function Database option).  You can use these by passing a Ruby regular expression to +like+ or +ilike+, or by making the regular expression a hash value:
 
   Sequel.like(:name, /^A/) # ("name" ~ '^A')
   ~Sequel.ilike(:name, /^A/) # ("name" !~* '^A')

data/lib/sequel/adapters/sqlite.rb

@@ -98,6 +98,11 @@ module Sequel
       # The conversion procs to use for this database
       attr_reader :conversion_procs
 
+      def initialize(opts = OPTS)
+        super
+        @allow_regexp = typecast_value_boolean(opts[:setup_regexp_function])
+      end
+
       # Connect to the database. Since SQLite is a file based database,
       # available options are limited:
       #
@@ -119,6 +124,12 @@ module Sequel
         end
         
         connection_pragmas.each{|s| log_connection_yield(s, db){db.execute_batch(s)}}
+
+        if typecast_value_boolean(opts[:setup_regexp_function])
+          db.create_function("regexp", 2) do |func, regexp_str, string|
+            func.result = Regexp.new(regexp_str).match(string) ? 1 : 0
+          end
+        end
         
         class << db
           attr_reader :prepared_statements
@@ -128,6 +139,12 @@ module Sequel
         db
       end
 
+      # Whether this Database instance is setup to allow regexp matching.
+      # True if the :setup_regexp_function option was passed when creating the Database.
+      def allow_regexp?
+        @allow_regexp
+      end
+
       # Disconnect given connections from the database.
       def disconnect_connection(c)
         c.prepared_statements.each_value{|v| v.first.close}
@@ -321,6 +338,28 @@ module Sequel
       BindArgumentMethods = prepared_statements_module(:bind, ArgumentMapper)
       PreparedStatementMethods = prepared_statements_module(:prepare, BindArgumentMethods)
 
+      # Support regexp functions if using :setup_regexp_function Database option.
+      def complex_expression_sql_append(sql, op, args)
+        case op
+        when :~, :'!~', :'~*', :'!~*'
+          return super unless supports_regexp?
+
+          case_insensitive = [:'~*', :'!~*'].include?(op)
+          sql << 'NOT ' if [:'!~', :'!~*'].include?(op)
+          sql << '('
+          sql << 'LOWER(' if case_insensitive
+          literal_append(sql, args[0])
+          sql << ')' if case_insensitive
+          sql << ' REGEXP '
+          sql << 'LOWER(' if case_insensitive
+          literal_append(sql, args[1])
+          sql << ')' if case_insensitive
+          sql << ')'
+        else
+          super
+        end
+      end
+
       def fetch_rows(sql)
         execute(sql) do |result|
           cps = db.conversion_procs
@@ -344,6 +383,11 @@ module Sequel
           end
         end
       end
+
+      # Support regexp if using :setup_regexp_function Database option.
+      def supports_regexp?
+        db.allow_regexp?
+      end
       
       private
       

data/lib/sequel/dataset/sql.rb

@@ -894,9 +894,10 @@ module Sequel
     # Clone of this dataset usable in aggregate operations.  Does
     # a from_self if dataset contains any parameters that would
     # affect normal aggregation, or just removes an existing
-    # order if not.
+    # order if not. Also removes the row_proc, which isn't needed
+    # for aggregate calculations.
     def aggregate_dataset
-      options_overlap(COUNT_FROM_SELF_OPTS) ? from_self : unordered
+      (options_overlap(COUNT_FROM_SELF_OPTS) ? from_self : unordered).naked
     end
 
     # Append aliasing expression to SQL string.

data/lib/sequel/plugins/auto_restrict_eager_graph.rb

@@ -0,0 +1,62 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The auto_restrict_eager_graph plugin will automatically disallow the use
+    # of eager_graph for associations that have associated blocks but no :graph_*
+    # association options.  The reason for this is the block will have an effect
+    # during regular and eager loading, but not loading via eager_graph, and it
+    # is likely that whatever the block is doing should have an equivalent done
+    # when eager_graphing.  Most likely, not including a :graph_* option was either
+    # an oversight (and one should be added), or use with eager_graph was never
+    # intended (and usage should be forbidden).  Disallowing eager_graph in this
+    # case prevents likely unexpected behavior during eager_graph.
+    #
+    # As an example of this, consider the following code:
+    #
+    #   Album.one_to_many :popular_tracks, class: :Track do |ds|
+    #     ds = ds.where(popular: true)
+    #   end  
+    #
+    #   Album.eager(:popular_tracks).all
+    #   # SELECT * FROM albums
+    #   # SELECT * FROM tracks WHERE ((popular IS TRUE) AND (album_id IN (...)))
+    #
+    #   # Notice that no condition for tracks.popular is added.
+    #   Album.eager_graph(:popular_tracks).all
+    #   # SELECT ... FROM albums LEFT JOIN tracks ON (tracks.album_id = albums.id)
+    #   
+    # With the auto_restrict_eager_graph plugin, the eager_graph call above will
+    # raise an error, alerting you to the fact that you either should not be
+    # using eager_graph with the association, or that you should be adding an
+    # appropriate :graph_* option, such as:
+    #
+    #   Album.one_to_many :popular_tracks, class: :Track, graph_conditions: {popular: true} do |ds|
+    #     ds = ds.where(popular: true)
+    #   end  
+    #
+    # Usage:
+    #
+    #   # Automatically restrict eager_graph for associations if appropriate for all
+    #   # model subclasses (called before loading subclasses)
+    #   Sequel::Model.plugin :auto_restrict_eager_graph
+    #
+    #   # Automatically restrict eager_graph for associations in Album class
+    #   Album.plugin :auto_restrict_eager_graph
+    module AutoRestrictEagerGraph
+      module ClassMethods
+        # When defining an association, if a block is given for the association, but
+        # a :graph_* option is not used, disallow the use of eager_graph.
+        def associate(type, name, opts = OPTS, &block)
+          opts = super
+
+          if opts[:block] && !opts.has_key?(:allow_eager_graph) && !opts[:orig_opts].any?{|k,| /\Agraph_/ =~ k}
+            opts[:allow_eager_graph] = false
+          end
+
+          opts
+        end
+      end
+    end
+  end
+end

data/lib/sequel/version.rb

@@ -6,7 +6,7 @@ module Sequel
 
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 54
+  MINOR = 55
 
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.54.0
+  version: 5.55.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-03-01 00:00:00.000000000 Z
+date: 2022-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -199,6 +199,7 @@ extra_rdoc_files:
 - doc/release_notes/5.52.0.txt
 - doc/release_notes/5.53.0.txt
 - doc/release_notes/5.54.0.txt
+- doc/release_notes/5.55.0.txt
 - doc/release_notes/5.6.0.txt
 - doc/release_notes/5.7.0.txt
 - doc/release_notes/5.8.0.txt
@@ -281,6 +282,7 @@ files:
 - doc/release_notes/5.52.0.txt
 - doc/release_notes/5.53.0.txt
 - doc/release_notes/5.54.0.txt
+- doc/release_notes/5.55.0.txt
 - doc/release_notes/5.6.0.txt
 - doc/release_notes/5.7.0.txt
 - doc/release_notes/5.8.0.txt
@@ -479,6 +481,7 @@ files:
 - lib/sequel/plugins/association_pks.rb
 - lib/sequel/plugins/association_proxies.rb
 - lib/sequel/plugins/async_thread_pool.rb
+- lib/sequel/plugins/auto_restrict_eager_graph.rb
 - lib/sequel/plugins/auto_validations.rb
 - lib/sequel/plugins/auto_validations_constraint_validations_presence_message.rb
 - lib/sequel/plugins/before_after_save.rb