sequel 4.36.0 → 5.61.0

data/lib/sequel/extensions/symbol_aref.rb

@@ -0,0 +1,55 @@
+# frozen-string-literal: true
+#
+# The symbol_aref extension makes Symbol#[] support Symbol,
+# Sequel::SQL::Indentifier, and Sequel::SQL::QualifiedIdentifier instances,
+# returning appropriate Sequel::SQL::QualifiedIdentifier instances.  It's
+# designed as a shortcut so that instead of:
+#
+#   Sequel[:table][:column] # table.column
+#
+# you can just write:
+#
+#   :table[:column] # table.column
+#
+# To load the extension:
+#
+#   Sequel.extension :symbol_aref
+#
+# If you are using Ruby 2+, and you would like to use refinements, there
+# is a refinement version of this in the symbol_aref_refinement extension.
+#
+# Related module: Sequel::SymbolAref
+
+if RUBY_VERSION >= '2.0'
+  module Sequel::SymbolAref
+    def [](v)
+      case v
+      when Symbol, Sequel::SQL::Identifier, Sequel::SQL::QualifiedIdentifier
+        Sequel::SQL::QualifiedIdentifier.new(self, v)
+      else
+        super
+      end
+    end
+  end
+
+  class Symbol
+    prepend Sequel::SymbolAref
+  end
+# :nocov:
+else
+  class Symbol
+    if method_defined?(:[])
+      alias_method :aref_before_sequel, :[] 
+    end
+
+    def [](v)
+      case v
+      when Symbol, Sequel::SQL::Identifier, Sequel::SQL::QualifiedIdentifier
+        Sequel::SQL::QualifiedIdentifier.new(self, v)
+      else
+        aref_before_sequel(v)
+      end
+    end
+  end
+end
+# :nocov:

data/lib/sequel/extensions/symbol_aref_refinement.rb

@@ -0,0 +1,43 @@
+# frozen-string-literal: true
+#
+# The symbol_aref_refinement extension adds a refinement that makes
+# Symbol#[] support Symbol, #Sequel::SQL::Indentifier, and
+# Sequel::SQL::QualifiedIdentifier instances, returning appropriate
+# Sequel::SQL::QualifiedIdentifier instances.  It's designed as a
+# shortcut so that instead of:
+#
+#   Sequel[:table][:column] # table.column
+#
+# you can just write:
+#   
+#   :table[:column] # table.column
+#
+# To load the extension:
+#
+#   Sequel.extension :symbol_aref_refinement
+#
+# To enable the refinement for the current file:
+#
+#   using Sequel::SymbolAref
+#
+# If you would like this extension to be enabled globally instead
+# of as a refinement, use the symbol_aref extension.
+#
+# Related module: Sequel::SymbolAref
+
+# :nocov:
+raise(Sequel::Error, "Refinements require ruby 2.0.0 or greater") unless RUBY_VERSION >= '2.0.0'
+# :nocov:
+
+module Sequel::SymbolAref
+  refine Symbol do
+    def [](v)
+      case v
+      when Symbol, Sequel::SQL::Identifier, Sequel::SQL::QualifiedIdentifier
+        Sequel::SQL::QualifiedIdentifier.new(self, v)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/sequel/extensions/symbol_as.rb

@@ -0,0 +1,23 @@
+# frozen-string-literal: true
+#
+# The symbol_as extension adds Symbol#as, for creating
+# Sequel::SQL::AliasedExpression objects. It's
+# designed as a shortcut so that instead of:
+#
+#   Sequel[:column].as(:alias)
+#
+# you can just write:
+#
+#   :column.as(:alias)
+#
+# To load the extension:
+#
+#   Sequel.extension :symbol_as
+#
+# If you are using Ruby 2+, and you would like to use refinements, there
+# is a refinement version of this in the symbol_as_refinement extension.
+
+# 
+class Symbol
+  include Sequel::SQL::AliasMethods
+end

data/lib/sequel/extensions/symbol_as_refinement.rb

@@ -0,0 +1,37 @@
+# frozen-string-literal: true
+#
+# The symbol_as_refinement extension adds a refinement that makes
+# Symbol#as return Sequel::SQL::AliasedExpression instances.  It's
+# designed as a shortcut so that instead of:
+#
+#   Sequel[:column].as(:alias) # column AS alias
+#
+# you can just write:
+#   
+#   :column.as(:alias) # column AS alias
+#
+# To load the extension:
+#
+#   Sequel.extension :symbol_as_refinement
+#
+# To enable the refinement for the current file:
+#
+#   using Sequel::SymbolAs
+#
+# If you would like this extension to be enabled globally instead
+# of as a refinement, use the symbol_as extension.
+#
+# Related module: Sequel::SymbolAs
+
+# :nocov:
+raise(Sequel::Error, "Refinements require ruby 2.0.0 or greater") unless RUBY_VERSION >= '2.0.0'
+# :nocov:
+
+module Sequel::SymbolAs
+  refine Symbol do
+    def as(aliaz, columns=nil)
+      Sequel::SQL::AliasedExpression.new(self, aliaz, columns)
+    end
+  end
+end
+

data/lib/sequel/extensions/synchronize_sql.rb

@@ -0,0 +1,45 @@
+# frozen-string-literal: true
+#
+# The synchronize_sql extension checks out a connection from the pool while
+# generating an SQL string.  In cases where a connection is necessary
+# in order to properly escape input, and multiple inputs in the query need
+# escaping, this can result in fewer connection checkouts and better
+# overall performance. In other cases this results in a performance decrease
+# because a connection is checked out and either not used or kept checked out
+# longer than necessary.
+#
+# The adapters where this extension may improve performance include amalgalite,
+# mysql2, postgres, jdbc/postgresql, and tinytds. In these adapters, escaping
+# strings requires a connection object for as proper escaping requires calling
+# an escaping method on the connection object.
+#
+# This extension is most helpful when dealing with queries with lots of
+# strings that need escaping (e.g. IN queries with long lists).  By default,
+# a connection will be checked out and back in for each string to be escaped,
+# which under high contention can cause the query to spend longer generating
+# the SQL string than the actual pool timeout (since every individual checkout
+# will take less than the timeout, but the sum of all of them can be greater).
+#
+# This extension is unnecessary and will decrease performance if the single
+# threaded connection pool is used.
+
+#
+module Sequel
+  class Dataset
+    module SynchronizeSQL
+      %w'insert select update delete'.each do |type|
+        define_method(:"#{type}_sql") do |*args|
+          if @opts[:sql].is_a?(String)
+            return super(*args)
+          end
+
+          db.synchronize(@opts[:server]) do
+            super(*args)
+          end
+        end
+      end
+    end
+
+    register_extension(:synchronize_sql, SynchronizeSQL)
+  end
+end

data/lib/sequel/extensions/to_dot.rb

@@ -53,7 +53,13 @@ module Sequel
     # is given, it is used directly as the node or transition.  Otherwise
     # a node is created for the current object.
     def dot(label, j=nil)
-      @dot << "#{j||@i} [label=#{label.to_s.inspect}];"
+      label = case label
+      when nil
+        "<nil>"
+      else
+        label.to_s
+      end
+      @dot << "#{j||@i} [label=#{label.inspect}];"
     end
 
     # Recursive method that parses all of Sequel's internal datastructures,
@@ -61,11 +67,11 @@ module Sequel
     # structure.
     def v(e, l)
       @i += 1
-      dot(l, "#{@stack.last} -> #{@i}") if l
+      dot(l, "#{@stack.last} -> #{@i}")
       @stack.push(@i)
       case e
       when LiteralString
-        dot "#{e.inspect}.lit" # core_sql use
+        dot "Sequel.lit(#{e.to_s.inspect})"
       when Symbol, Numeric, String, Class, TrueClass, FalseClass, NilClass
         dot e.inspect
       when Array
@@ -144,7 +150,7 @@ module Sequel
         dot "Dataset"
         TO_DOT_OPTIONS.each do |k|
           if val = e.opts[k]
-            v(val, k.to_s) 
+            v(val, k) 
           end
         end
       else

data/lib/sequel/extensions/virtual_row_method_block.rb

@@ -0,0 +1,44 @@
+# frozen-string-literal: true
+#
+# These modifies virtual row blocks so that you can pass a block
+# when calling a method to change the behavior.  It only exists
+# for backwards compatibility with previous Sequel versions, and
+# is not recommended for new applications.
+# 
+# To load the extension:
+#
+#   Sequel.extension :virtual_row_method_block
+
+#
+module Sequel
+  module SQL
+    class VirtualRow < BasicObject
+      include(Module.new do
+        # Handle blocks passed to methods and change the behavior.
+        def method_missing(m, *args, &block)
+          if block
+            if args.empty?
+              Function.new(m)
+            else
+              case args.shift
+              when :*
+                Function.new(m, *args).*
+              when :distinct
+                Function.new(m, *args).distinct
+              when :over
+                opts = args.shift || OPTS
+                f = Function.new(m, *::Kernel.Array(opts[:args]))
+                f = f.* if opts[:*]
+                f.over(opts)
+              else
+                Kernel.raise(Error, 'unsupported VirtualRow method argument used with block')
+              end
+            end
+          else
+            super
+          end
+        end
+      end)
+    end
+  end
+end