sequel 4.26.0 → 5.37.0

data/lib/sequel/extensions/eval_inspect.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+#
 # The eval_inspect extension changes #inspect for Sequel::SQL::Expression
 # subclasses to return a string suitable for ruby's eval, such that
 #
@@ -11,6 +13,8 @@
 # To load the extension:
 #
 #   Sequel.extension :eval_inspect
+#
+# Related module: Sequel::EvalInspect
 
 #
 module Sequel
@@ -22,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
@@ -69,9 +66,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,32 +1,3 @@
-# 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
-
-#
-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
+# frozen-string-literal: true
 
+Sequel::Database.register_extension(:from_block){}

data/lib/sequel/extensions/graph_each.rb

@@ -1,8 +1,10 @@
+# frozen-string-literal: true
+#
 # The graph_each extension adds Dataset#graph_each and
 # 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:
@@ -14,6 +16,8 @@
 # is probably the desired behavior if you are using this extension:
 #
 #   DB.extension(:graph_each)
+#
+# Related module: Sequel::GraphEach
 
 #
 module Sequel
@@ -27,24 +31,33 @@ module Sequel
       end
     end
 
+    # Call graph_each for graphed datasets that are not being eager graphed.
+    def with_sql_each(sql)
+      if @opts[:graph] && !@opts[:eager_graph]
+        graph_each(sql){|r| yield r}
+      else
+        super
+      end
+    end
+
     private
 
     # Fetch the rows, split them into component table parts,
     # tranform and run the row_proc on each part (if applicable),
     # and yield a hash of the parts.
-    def graph_each
+    def graph_each(sql=select_sql)
       # Reject tables with nil datasets, as they are excluded from
       # 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]
-      fetch_rows(select_sql) do |r|
+      column_aliases = @opts[:graph][:column_aliases]
+      fetch_rows(sql) do |r|
         graph = {}
         # Create the sub hashes, one per table
         table_aliases.each{|ta| graph[ta]={}}

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