sequel 4.36.0 → 5.61.0

data/lib/sequel/extensions/duplicate_columns_handler.rb

@@ -10,24 +10,28 @@
 #
 #   DB.extension :duplicate_columns_handler
 #
+# or into individual datasets:
+#
+#   ds = DB[:items].extension(:duplicate_columns_handler)
+#
 # A database option is introduced: :on_duplicate_columns. It accepts a Symbol
 # or any object that responds to :call.
 #
-#   :on_duplicate_columns => :raise
-#   :on_duplicate_columns => :warn
-#   :on_duplicate_columns => :ignore
-#   :on_duplicate_columns => proc { |columns| arbitrary_condition? ? :raise : :warn }
+#   on_duplicate_columns: :raise
+#   on_duplicate_columns: :warn
+#   on_duplicate_columns: :ignore
+#   on_duplicate_columns: lambda{|columns| arbitrary_condition? ? :raise : :warn}
 #
 # You may also configure duplicate columns handling for a specific dataset:
 #
 #   ds.on_duplicate_columns(:warn)
 #   ds.on_duplicate_columns(:raise)
 #   ds.on_duplicate_columns(:ignore)
-#   ds.on_duplicate_columns { |columns| arbitrary_condition? ? :raise : :warn }
-#   ds.on_duplicate_columns(proc { |columns| arbitrary_condition? ? :raise : :warn })
+#   ds.on_duplicate_columns{|columns| arbitrary_condition? ? :raise : :warn}
+#   ds.on_duplicate_columns(lambda{|columns| arbitrary_condition? ? :raise : :warn})
 #
 # If :raise is specified, a Sequel::DuplicateColumnError is raised.
-# If :warn is specified, you will receive a warning via `warn`.
+# If :warn is specified, you will receive a warning via +warn+.
 # If a callable is specified, it will be called.
 # If no on_duplicate_columns is specified, the default is :warn.
 #
@@ -35,26 +39,29 @@
 
 module Sequel
   module DuplicateColumnsHandler
+    # :nocov:
+    CALLER_ARGS = (RUBY_VERSION >= '2.0' ? [0,1] : [0]).freeze
+    # :nocov:
+
     # Customize handling of duplicate columns for this dataset.
-    def on_duplicate_columns(handler = (raise Error, "Must provide either an argument or a block to on_duplicate_columns" unless block_given?; nil), &block)
+    def on_duplicate_columns(handler = (raise Error, "Must provide either an argument or a block to on_duplicate_columns" unless defined?(yield); nil), &block)
       raise Error, "Cannot provide both an argument and a block to on_duplicate_columns" if handler && block
       clone(:on_duplicate_columns=>handler||block)
     end
 
-    # Override the attr_writer to check for duplicate columns, and call
-    # handle_duplicate_columns if necessary.
+    private
+
+    # Call handle_duplicate_columns if there are duplicate columns.
     def columns=(cols)
       if cols && cols.uniq.size != cols.size
         handle_duplicate_columns(cols)
       end
-      @columns = cols
+      super
     end
 
-    private
-
     # Invoke the appropriate behavior when duplicate columns are present.
     def handle_duplicate_columns(cols)
-      message = "One or more duplicate columns present in #{cols.inspect}"
+      message = "#{caller(*CALLER_ARGS).first}: One or more duplicate columns present in #{cols.inspect}"
 
       case duplicate_columns_handler_type(cols)
       when :raise

data/lib/sequel/extensions/empty_array_consider_nulls.rb

@@ -4,9 +4,9 @@
 # array value to consider NULL values if one of the referenced
 # columns is NULL:
 #
-#   DB[:test].where(:name=>[])
+#   DB[:test].where(name: [])
 #   # SELECT * FROM test WHERE (name != name)
-#   DB[:test].exclude(:name=>[])
+#   DB[:test].exclude(name: [])
 #   # SELECT * FROM test WHERE (name = name)
 #
 # The default Sequel behavior is to ignore NULLs, as the above

data/lib/sequel/extensions/escaped_like.rb

@@ -0,0 +1,100 @@
+# frozen-string-literal: true
+#
+# The escaped_like extension adds +escaped_like+ and +escaped_ilike+
+# methods to Sequel::SQL::StringMethods, which allow them to be easily
+# used with most of Sequel's expression objects.  Example:
+#
+#   DB[:table].where{string_column.escaped_like('?%', user_input)}
+#   # user_input is 'foo':
+#   #  SELECT * FROM table WHERE string_column LIKE 'foo%' ESCAPE '\'
+#   # user_input is '%foo':
+#   #  SELECT * FROM table WHERE string_column LIKE '\%foo%' ESCAPE '\'
+#
+# To load the extension:
+#
+#   Sequel.extension :escaped_like
+#
+# Related modules: Sequel::SQL::StringMethods, Sequel::SQL::EscapedLikeExpression
+
+#
+module Sequel
+  module SQL
+    # Represents an pattern match SQL expression, where the pattern can depend
+    # upon interpolated values in a database-dependent manner.
+    class EscapedLikeExpression < Expression
+      include AliasMethods
+      include BooleanMethods
+      include CastMethods
+      include OrderMethods
+
+      # Initialize the expression. Arguments:
+      # expr :: Right hand site of LIKE/ILIKE operator, what you are matching against the pattern
+      # case_insensitive :: Whether the match is case sensitive
+      # placeholder_pattern :: The pattern to match against, with +?+ for the placeholders
+      # placeholder_values :: The string values for each +?+ in the placeholder pattern.  Should be an
+      #                       array of strings, though it can be a single string if there is only
+      #                       a single placeholder.
+      def initialize(expr, case_sensitive, placeholder_pattern, placeholder_values)
+        @expr = expr
+        @method = case_sensitive ? :like : :ilike
+        @pattern = placeholder_pattern
+        unless placeholder_values.is_a?(Array)
+          placeholder_values = [placeholder_values].freeze
+        end
+        @values = placeholder_values
+        freeze
+      end
+
+      # Interpolate the pattern values into the placeholder pattern to get the final pattern,
+      # now that we have access to the dataset.  Use the expression and final pattern and
+      # add an appropriate LIKE/ILIKE expression to the SQL being built.
+      def to_s_append(ds, sql)
+        i = -1
+        match_len = @values.length - 1
+        like_pattern = String.new
+        pattern = @pattern
+        while true
+          previous, q, pattern = pattern.partition('?')
+          like_pattern << previous
+
+          unless q.empty?
+            if i == match_len
+              raise Error, "Mismatched number of placeholders (#{i+1}) and placeholder arguments (#{@values.length}) for escaped like expression: #{@pattern.inspect}"
+            end
+            like_pattern << ds.escape_like(@values.at(i+=1))
+          end
+
+          if pattern.empty?
+            unless i == match_len
+              raise Error, "Mismatched number of placeholders (#{i+1}) and placeholder arguments (#{@values.length}) for escaped like expression: #{@pattern.inspect}"
+            end
+            break
+          end
+        end
+        ds.literal_append(sql, Sequel.send(@method, @expr, like_pattern))
+      end
+    end
+
+    module StringMethods
+      # Create a +EscapedLikeExpression+ case insensitive pattern match of the receiver
+      # with the patterns, interpolated escaped values for each +?+ placeholder in the
+      # pattern. 
+      #
+      #   Sequel[:a].escaped_ilike('?%', 'A') # "a" ILIKE 'A%' ESCAPE '\'
+      #   Sequel[:a].escaped_ilike('?%', '%A') # "a" ILIKE '\%A%' ESCAPE '\'
+      def escaped_ilike(placeholder_pattern, placeholder_values)
+        EscapedLikeExpression.new(self, false, placeholder_pattern, placeholder_values)
+      end
+
+      # Create a +EscapedLikeExpression+ case sensitive pattern match of the receiver
+      # with the patterns, interpolated escaped values for each +?+ placeholder in the
+      # pattern. 
+      #
+      #   Sequel[:a].escaped_like('?%', 'A') # "a" LIKE 'A%' ESCAPE '\'
+      #   Sequel[:a].escaped_like('?%', '%A') # "a" LIKE '\%A%' ESCAPE '\'
+      def escaped_like(placeholder_pattern, placeholder_values)
+        EscapedLikeExpression.new(self, true, placeholder_pattern, placeholder_values)
+      end
+    end
+  end
+end

data/lib/sequel/extensions/eval_inspect.rb

@@ -26,32 +26,25 @@ module Sequel
     # for eval.
     def eval_inspect(obj)
       case obj
-      when Sequel::SQL::Blob, Sequel::LiteralString, Sequel::SQL::ValueList
-        "#{obj.class}.new(#{obj.inspect})"
+      when BigDecimal
+        "Kernel::BigDecimal(#{obj.to_s.inspect})"
+      when Sequel::SQL::Blob, Sequel::LiteralString
+        "#{obj.class}.new(#{obj.to_s.inspect})"
+      when Sequel::SQL::ValueList
+        "#{obj.class}.new(#{obj.to_a.inspect})"
       when Array
         "[#{obj.map{|o| eval_inspect(o)}.join(', ')}]"
       when Hash
         "{#{obj.map{|k, v| "#{eval_inspect(k)} => #{eval_inspect(v)}"}.join(', ')}}"
       when Time
         datepart = "%Y-%m-%dT" unless obj.is_a?(Sequel::SQLTime)
-        if RUBY_VERSION < '1.9'
-        # :nocov:
-          # Time on 1.8 doesn't handle %N (or %z on Windows), manually set the usec value in the string
-          hours, mins = obj.utc_offset.divmod(3600)
-          mins /= 60
-          "#{obj.class}.parse(#{obj.strftime("#{datepart}%H:%M:%S.#{sprintf('%06i%+03i%02i', obj.usec, hours, mins)}").inspect})#{'.utc' if obj.utc?}"
-        # :nocov:
-        else
-          "#{obj.class}.parse(#{obj.strftime("#{datepart}%T.%N%z").inspect})#{'.utc' if obj.utc?}"
-        end
+        "#{obj.class}.parse(#{obj.strftime("#{datepart}%T.%N%z").inspect})#{'.utc' if obj.utc?}"
       when DateTime
         # Ignore date of calendar reform
         "DateTime.parse(#{obj.strftime('%FT%T.%N%z').inspect})"
       when Date
         # Ignore offset and date of calendar reform
         "Date.new(#{obj.year}, #{obj.month}, #{obj.day})"
-      when BigDecimal
-        "BigDecimal.new(#{obj.to_s.inspect})"
       else
         obj.inspect
       end
@@ -62,6 +55,8 @@ module Sequel
 
   module SQL
     class Expression
+      alias inspect inspect
+
       # Attempt to produce a string suitable for eval, such that:
       #
       #   eval(obj.inspect) == obj
@@ -73,9 +68,11 @@ module Sequel
         args = inspect_args.map do |arg|
           if arg.is_a?(String) && arg =~ /\A\*/
             # Special case string arguments starting with *, indicating that
-            # they should return an array to be splatted as the remaining arguments
+            # they should return an array to be splatted as the remaining arguments.
+            # Allow calling private methods to get inspect output.
             send(arg.sub('*', '')).map{|a| Sequel.eval_inspect(a)}.join(', ')
           else
+            # Allow calling private methods to get inspect output.
             Sequel.eval_inspect(send(arg))
           end
         end

data/lib/sequel/extensions/exclude_or_null.rb

@@ -0,0 +1,68 @@
+# frozen-string-literal: true
+#
+# The exclude_or_null extension adds Dataset#exclude_or_null and
+# Dataset#exclude_or_null_having.  These methods are similar to
+# Dataset#exclude and Dataset#exclude_having, except that they
+# will also exclude rows where the condition IS NULL.
+#
+#   DB[:table].exclude_or_null(foo: 1)
+#   # SELECT * FROM table WHERE NOT coalesce((foo = 1), false)
+#   
+#   DB[:table].exclude_or_null{foo(bar) =~ 1}
+#   # SELECT * FROM table HAVING NOT coalesce((foo(bar) = 1), false))
+#   
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds = ds.extension(:exclude_or_null)
+#
+# Or you can load it into all of a database's datasets, which
+# is probably the desired behavior if you are using this extension:
+#
+#   DB.extension(:exclude_or_null)
+#
+# Note, this extension works correctly on PostgreSQL, SQLite, MySQL,
+# H2, and HSQLDB.  However, it does not work correctly on Microsoft SQL Server,
+# Oracle, DB2, SQLAnywhere, or Derby.
+#
+# Related module: Sequel::ExcludeOrNull
+
+#
+module Sequel
+  module ExcludeOrNull
+    # Performs the inverse of Dataset#where, but also excludes rows where the given
+    # condition IS NULL.
+    #
+    #   DB[:items].exclude_or_null(category: 'software')
+    #   # SELECT * FROM items WHERE NOT coalesce((category = 'software'), false)
+    #   
+    #   DB[:items].exclude_or_null(category: 'software', id: 3)
+    #   # SELECT * FROM items WHERE NOT coalesce(((category = 'software') AND (id = 3)), false)
+    def exclude_or_null(*cond, &block)
+      add_filter(:where, cond, :or_null, &block)
+    end
+
+    # The same as exclude_or_null, but affecting the HAVING clause instead of the
+    # WHERE clause.
+    #
+    #   DB[:items].select_group(:name).exclude_or_null_having{count(name) < 2}
+    #   # SELECT name FROM items GROUP BY name HAVING NOT coalesce((count(name) < 2), true)
+    def exclude_or_null_having(*cond, &block)
+      add_filter(:having, cond, :or_null, &block)
+    end
+
+    private
+
+    # Recognize :or_null value for invert, returning an expression for
+    # the invert of the condition or the condition being null.
+    def _invert_filter(cond, invert)
+      if invert == :or_null
+        ~SQL::Function.new(:coalesce, cond, SQL::Constants::SQLFALSE)
+      else
+        super
+      end
+    end
+  end
+
+  Dataset.register_extension(:exclude_or_null, ExcludeOrNull)
+end

data/lib/sequel/extensions/fiber_concurrency.rb

@@ -0,0 +1,24 @@
+# frozen-string-literal: true
+#
+# The fiber_concurrency extension changes the default concurrency
+# primitive in Sequel to be Fiber.current instead of Thread.current.
+# This is the value used in various hash keys to implement safe
+# concurrency (thread-safe concurrency by default, fiber-safe
+# concurrency with this extension.  It can be enabled via:
+#
+#   Sequel.extension :fiber_concurrency
+#   
+# Related module: Sequel::FiberConcurrency
+
+require 'fiber'
+
+module Sequel
+  module FiberConcurrency
+    # Make the current concurrency primitive be Fiber.current.
+    def current
+      Fiber.current
+    end
+  end
+
+  extend FiberConcurrency
+end

data/lib/sequel/extensions/freeze_datasets.rb

@@ -0,0 +1,3 @@
+# frozen-string-literal: true
+
+Sequel::Database.register_extension(:freeze_datasets){}

data/lib/sequel/extensions/from_block.rb

@@ -1,36 +1,3 @@
 # frozen-string-literal: true
-#
-# The from_block extension changes Database#from so that blocks given
-# to it are treated as virtual rows applying to the FROM clause,
-# instead of virtual rows applying to the WHERE clause.  This will
-# probably be made the default in the next major version of Sequel.
-#
-# This makes it easier to use table returning functions:
-#
-#   DB.from{table_function(1)}
-#   # SELECT * FROM table_function(1)
-#
-# To load the extension into the database:
-#
-#   DB.extension :from_block
-#
-# Related module: Sequel::Database::FromBlock
-
-#
-module Sequel
-  module Database::FromBlock
-    # If a block is given, make it affect the FROM clause:
-    #   DB.from{table_function(1)}
-    #   # SELECT * FROM table_function(1)
-    def from(*args, &block)
-      if block
-        @default_dataset.from(*args, &block)
-      else
-        super
-      end
-    end
-  end
-
-  Database.register_extension(:from_block, Database::FromBlock)
-end
 
+Sequel::Database.register_extension(:from_block){}

data/lib/sequel/extensions/graph_each.rb

@@ -4,7 +4,7 @@
 # makes Dataset#each call #graph_each if the dataset has been graphed.
 # Dataset#graph_each splits result hashes into subhashes per table:
 #
-#   DB[:a].graph(:b, :id=>:b_id).all
+#   DB[:a].graph(:b, id: :b_id).all
 #   # => {:a=>{:id=>1, :b_id=>2}, :b=>{:id=>2}}
 #
 # You can load this extension into specific datasets:
@@ -50,13 +50,13 @@ module Sequel
       # the result set
       datasets = @opts[:graph][:table_aliases].to_a.reject{|ta,ds| ds.nil?}
       # Get just the list of table aliases into a local variable, for speed
-      table_aliases = datasets.collect{|ta,ds| ta}
+      table_aliases = datasets.map{|ta,ds| ta}
       # Get an array of arrays, one for each dataset, with
       # the necessary information about each dataset, for speed
-      datasets = datasets.collect{|ta, ds| [ta, ds, ds.row_proc]}
+      datasets = datasets.map{|ta, ds| [ta, ds, ds.row_proc]}
       # Use the manually set graph aliases, if any, otherwise
       # use the ones automatically created by .graph
-      column_aliases = @opts[:graph_aliases] || @opts[:graph][:column_aliases]
+      column_aliases = @opts[:graph][:column_aliases]
       fetch_rows(sql) do |r|
         graph = {}
         # Create the sub hashes, one per table

data/lib/sequel/extensions/identifier_mangling.rb

@@ -0,0 +1,180 @@
+# frozen-string-literal: true
+#
+# The identifier_mangling extension adds support for to change
+# the default identifier mangling for datasets, as well as all
+# datasets for a given database.
+#
+#   # Use uppercase identifiers in database, and lowercase in ruby.
+#   # Default behavior of Sequel, as the SQL standard behavior
+#   # folds unquoted identifiers to uppercase.
+#   DB.identifier_input_method = :upcase
+#   DB.identifier_output_method = :downcase
+#   
+#   # Don't modify identifiers.
+#   # Default behavior of Sequel on PostgreSQL, MySQL, SQLite,
+#   # as they fold unquoted identifiers to lowercase.
+#   DB.identifier_input_method = nil
+#   DB.identifier_output_method = nil
+#
+# You can also choose to turn on or off identifier quoting:
+#
+#   # Quote identifiers.  Sequel's default behavior.
+#   DB.quote_identifiers = true
+# 
+#   # Don't quote identifiers.  Sequel's default behavior on DB2.
+#   DB.quote_identifiers = false
+#   
+# To modify the identifiers on a per-dataset basis:
+#
+#   ds = DB[:a].with_input_indentifier(:upcase).
+#               with_output_identifier(:downcase).
+#               with_quote_identifiers(true)
+#
+# To load the extension into the database:
+#
+#   DB.extension :identifier_mangling
+#
+# Related modules: Sequel::IdentifierMangling::DatabaseMethods,
+# Sequel::IdentifierMangling::DatasetMethods
+
+#
+module Sequel
+  module IdentifierMangling
+    module DatabaseMethods
+      def self.extended(db)
+        db.instance_exec do
+          @identifier_input_method = nil
+          @identifier_output_method = nil
+          @quote_identifiers = nil
+          reset_identifier_mangling
+          extend_datasets(DatasetMethods)
+        end
+      end
+
+      # The identifier input method to use by default for this database (default: adapter default)
+      attr_reader :identifier_input_method
+
+      # The identifier output method to use by default for this database (default: adapter default)
+      attr_reader :identifier_output_method
+
+      # Set the method to call on identifiers going into the database:
+      #
+      #   DB[:items] # SELECT * FROM items
+      #   DB.identifier_input_method = :upcase
+      #   DB[:items] # SELECT * FROM ITEMS
+      def identifier_input_method=(v)
+        reset_default_dataset
+        @identifier_input_method = v
+      end
+      
+      # Set the method to call on identifiers coming from the database:
+      #
+      #   DB[:items].first # {:id=>1, :name=>'foo'}
+      #   DB.identifier_output_method = :upcase
+      #   DB[:items].first # {:ID=>1, :NAME=>'foo'}
+      def identifier_output_method=(v)
+        reset_default_dataset
+        @identifier_output_method = v
+      end
+
+      # Set whether to quote identifiers (columns and tables) for this database:
+      #
+      #   DB[:items] # SELECT * FROM items
+      #   DB.quote_identifiers = true
+      #   DB[:items] # SELECT * FROM "items"
+      def quote_identifiers=(v)
+        reset_default_dataset
+        @quote_identifiers = v
+      end
+      
+      # Returns true if the database quotes identifiers.
+      def quote_identifiers?
+        @quote_identifiers
+      end
+
+      private
+
+      # Return a dataset that uses the default identifier input and output methods
+      # for this database.  Used when parsing metadata so that column symbols are
+      # returned as expected.
+      def _metadata_dataset
+        super.
+          with_identifier_input_method(identifier_input_method_default).
+          with_identifier_output_method(identifier_output_method_default)
+      end
+
+      # Upcase identifiers on input if database folds unquoted identifiers to
+      # uppercase.
+      def identifier_input_method_default
+        return super if defined?(super)
+        :upcase if folds_unquoted_identifiers_to_uppercase?
+      end
+
+      # Downcase identifiers on output if database folds unquoted identifiers to
+      # uppercase.
+      def identifier_output_method_default
+        return super if defined?(super)
+        :downcase if folds_unquoted_identifiers_to_uppercase?
+      end
+
+      # Reset the identifier mangling options.  Overrides any already set on
+      # the instance.  Only for internal use by shared adapters.
+      def reset_identifier_mangling
+        @quote_identifiers = @opts.fetch(:quote_identifiers, quote_identifiers_default)
+        @identifier_input_method = @opts.fetch(:identifier_input_method, identifier_input_method_default)
+        @identifier_output_method = @opts.fetch(:identifier_output_method, identifier_output_method_default)
+        reset_default_dataset
+      end
+    end
+
+    module DatasetMethods
+      # The String instance method to call on identifiers before sending them to
+      # the database.
+      def identifier_input_method
+        @opts.fetch(:identifier_input_method, db.identifier_input_method)
+      end
+      
+      # The String instance method to call on identifiers before sending them to
+      # the database.
+      def identifier_output_method
+        @opts.fetch(:identifier_output_method, db.identifier_output_method)
+      end
+    
+      # Check with the database to see if identifier quoting is enabled
+      def quote_identifiers?
+        @opts.fetch(:quote_identifiers, db.quote_identifiers?)
+      end
+
+      # Return a modified dataset with identifier_input_method set.
+      def with_identifier_input_method(meth)
+        clone(:identifier_input_method=>meth, :skip_symbol_cache=>true)
+      end
+      
+      # Return a modified dataset with identifier_output_method set.
+      def with_identifier_output_method(meth)
+        clone(:identifier_output_method=>meth)
+      end
+
+      private
+
+      # Convert the identifier to the version used in the database via
+      # identifier_input_method.
+      def input_identifier(v)
+        (i = identifier_input_method) ? v.to_s.public_send(i) : v.to_s
+      end
+
+      # Modify the identifier returned from the database based on the
+      # identifier_output_method.
+      def output_identifier(v)
+        v = 'untitled' if v == ''
+        (i = identifier_output_method) ? v.to_s.public_send(i).to_sym : v.to_sym
+      end
+
+      def non_sql_option?(key)
+        super || key == :identifier_input_method || key == :identifier_output_method
+      end
+    end
+  end
+
+  Database.register_extension(:identifier_mangling, IdentifierMangling::DatabaseMethods)
+end

data/lib/sequel/extensions/implicit_subquery.rb

@@ -0,0 +1,48 @@
+# frozen-string-literal: true
+#
+# The implicit_subquery extension changes most dataset methods that
+# return modified datasets to implicitly call from_self if the database
+# currently uses raw SQL.  Sequel's by default does not do this:
+#
+#   DB["SELECT * FROM table"].select(:column).sql
+#   # => "SELECT * FROM table"
+#
+# With this extension, datasets that use raw SQL are implicitly wrapped
+# in a subquery:
+#
+#   DB["SELECT * FROM table"].select(:column).sql
+#   # => "SELECT column FROM (SELECT * FROM table) AS t1"
+#
+# To add this extension to an existing dataset:
+#
+#   ds = ds.extension(:implicit_subquery)
+#
+# To set this as the default behavior for all datasets on a single database:
+#
+#   DB.extension(:implicit_subquery)
+#
+# Related module: Sequel::Dataset::ImplicitSubquery
+
+#
+module Sequel
+  class Dataset
+    module ImplicitSubquery
+      exceptions = [:add_graph_aliases, :filter, :from, :from_self, :naked, :or, :order_more,
+                    :qualify, :reverse, :reverse_order, :select_all, :select_more, :server,
+                    :set_graph_aliases, :unfiltered, :ungraphed, :ungrouped, :unlimited, :unordered,
+                    :with_sql]
+      additions = [:join_table]
+      (Dataset::QUERY_METHODS - Dataset::JOIN_METHODS - exceptions + additions).each do |meth|
+        define_method(meth) do |*a, &b|
+          if opts[:sql]
+            from_self.public_send(meth, *a, &b)
+          else
+            super(*a, &b)
+          end
+        end
+      end
+    end
+
+    register_extension(:implicit_subquery, ImplicitSubquery)
+  end
+end