sequel 4.26.0 → 5.37.0

data/lib/sequel/extensions/sql_expr.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+#
 # The sql_expr extension adds the sql_expr method to every object, which
 # returns an wrapped object that works nicely with Sequel's DSL by calling
 # Sequel.expr:
@@ -12,9 +14,10 @@
 #
 #   Sequel.extension :sql_expr
 
+#
 class Object
   # Return the object wrapper in an appropriate Sequel expression object.
   def sql_expr
-    Sequel.expr(self)
+    Sequel[self]
   end
 end

data/lib/sequel/extensions/string_agg.rb

@@ -0,0 +1,181 @@
+# frozen-string-literal: true
+#
+# The string_agg extension adds the ability to perform database-independent
+# aggregate string concatentation.  For example, with a table like:
+#
+#   c1 | c2
+#   ---+---
+#   a  | 1
+#   a  | 2
+#   a  | 3
+#   b  | 4
+#
+# You can return a result set like:
+#
+#   c1 | c2s
+#   ---+---
+#   a  | 1,2,3
+#   b  | 4
+#
+# First, you need to load the extension into the database:
+#
+#   DB.extension :string_agg
+#
+# Then you can use the Sequel.string_agg method to return a Sequel
+# expression:
+#
+#   sa = Sequel.string_agg(:column_name)
+#   # or:
+#   sa = Sequel.string_agg(:column_name, '-') # custom separator
+#
+# You can specify the order in which the concatention happens by
+# calling +order+ on the expression:
+#
+#   sa = Sequel.string_agg(:column_name).order(:other_column)
+#
+# Additionally, if you want to have the concatenation only operate
+# on distinct values, you can call distinct:
+#
+#   sa = Sequel.string_agg(:column_name).order(:other_column).distinct
+#
+# These expressions can be used in your datasets, or anywhere else that
+# Sequel expressions are allowed:
+#
+#   DB[:table].
+#     select_group(:c1).
+#     select_append(Sequel.string_agg(:c2))
+#
+# This extension currenly supports the following databases:
+#
+# * PostgreSQL 9+
+# * SQLAnywhere 12+
+# * Oracle 11g+ (except distinct)
+# * DB2 9.7+ (except distinct)
+# * MySQL
+# * HSQLDB
+# * H2
+#
+# Related module: Sequel::SQL::StringAgg
+
+#
+module Sequel
+  module SQL
+    module Builders
+      # Return a StringAgg expression for an aggregate string concatentation.
+      def string_agg(*a)
+        StringAgg.new(*a)
+      end
+    end
+
+    # The StringAgg class represents an aggregate string concatentation.
+    class StringAgg < GenericExpression
+      include StringMethods
+      include StringConcatenationMethods
+      include InequalityMethods
+      include AliasMethods
+      include CastMethods
+      include OrderMethods
+      include PatternMatchMethods
+      include SubscriptMethods
+
+      # These methods are added to datasets using the string_agg
+      # extension, for the purposes of correctly literalizing StringAgg
+      # expressions for the appropriate database type.
+      module DatasetMethods
+        # Append the SQL fragment for the StringAgg expression to the SQL query.
+        def string_agg_sql_append(sql, sa)
+          if defined?(super)
+            return super
+          end
+
+          expr = sa.expr
+          separator = sa.separator || ","
+          order = sa.order_expr
+          distinct = sa.is_distinct?
+
+          case db_type = db.database_type
+          when :postgres, :sqlanywhere
+            f = Function.new(db_type == :postgres ? :string_agg : :list, expr, separator)
+            if order
+              f = f.order(*order)
+            end
+            if distinct
+              f = f.distinct
+            end
+            literal_append(sql, f)
+          when :mysql, :hsqldb, :h2
+            sql << "GROUP_CONCAT("
+            if distinct
+              sql << "DISTINCT "
+            end
+            literal_append(sql, expr)
+            if order
+              sql << " ORDER BY "
+              expression_list_append(sql, order)
+            end
+            sql << " SEPARATOR "
+            literal_append(sql, separator)
+            sql << ")"
+          when :oracle, :db2
+            if distinct
+              raise Error, "string_agg with distinct is not implemented on #{db.database_type}"
+            end
+            literal_append(sql, Function.new(:listagg, expr, separator))
+            if order
+              sql << " WITHIN GROUP (ORDER BY "
+              expression_list_append(sql, order)
+              sql << ")"
+            else
+              sql << " WITHIN GROUP (ORDER BY 1)"
+            end
+          else
+            raise Error, "string_agg is not implemented on #{db.database_type}"
+          end
+        end
+      end
+
+      # The string expression for each row that will concatenated to the output.
+      attr_reader :expr
+
+      # The separator between each string expression.
+      attr_reader :separator
+
+      # The expression that the aggregation is ordered by.
+      attr_reader :order_expr
+
+      # Set the expression and separator
+      def initialize(expr, separator=nil)
+        @expr = expr
+        @separator = separator
+        yield self if block_given?
+        freeze
+      end
+
+      # Whether the current expression uses distinct expressions 
+      def is_distinct?
+        @distinct == true
+      end
+
+      # Return a modified StringAgg that uses distinct expressions
+      def distinct
+        self.class.new(@expr, @separator) do |sa|
+          sa.instance_variable_set(:@order_expr, @order_expr) if @order_expr
+          sa.instance_variable_set(:@distinct, true)
+        end
+      end
+
+      # Return a modified StringAgg with the given order
+      def order(*o)
+        self.class.new(@expr, @separator) do |sa|
+          sa.instance_variable_set(:@distinct, @distinct) if @distinct
+          sa.instance_variable_set(:@order_expr, o.empty? ? nil : o.freeze)
+        end
+      end
+
+      to_s_method :string_agg_sql
+    end
+  end
+
+  Dataset.register_extension(:string_agg, SQL::StringAgg::DatasetMethods)
+end
+

data/lib/sequel/extensions/string_date_time.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+#
 # The string_date_time extension provides String instance methods
 # for converting the strings to a date (e.g. String#to_date), allowing
 # for backwards compatibility with legacy Sequel code.

data/lib/sequel/extensions/symbol_aref.rb

@@ -0,0 +1,53 @@
+# 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
+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

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/thread_local_timezones.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+#
 # The thread_local_timezones extension allows you to set a per-thread timezone that
 # will override the default global timezone while the thread is executing.  The
 # main use case is for web applications that execute each request in its own thread,
@@ -33,6 +35,8 @@
 #   Sequel.application_timezone # => :utc
 #   Sequel.thread_application_timezone = :nil
 #   Sequel.application_timezone # => nil
+#
+# Related module: Sequel::ThreadLocalTimezones
 
 #
 module Sequel

data/lib/sequel/extensions/to_dot.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+#
 # This adds a <tt>Sequel::Dataset#to_dot</tt> method.  The +to_dot+ method
 # returns a string that can be processed by graphviz's +dot+ program in
 # order to get a visualization of the dataset.  Basically, it shows a version
@@ -6,6 +8,8 @@
 # To load the extension:
 #
 #   Sequel.extension :to_dot
+#
+# Related module: Sequel::ToDot
 
 #
 module Sequel
@@ -49,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,
@@ -57,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
@@ -123,7 +133,7 @@ module Sequel
         dot "PlaceholderLiteralString: #{str.inspect}"
         v(e.args, :args)
       when SQL::JoinClause
-        str = "#{e.join_type.to_s.upcase} JOIN"
+        str = "#{e.join_type.to_s.upcase} JOIN".dup
         if e.is_a?(SQL::JoinOnClause)
           str << " ON"
         elsif e.is_a?(SQL::JoinUsingClause)
@@ -140,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