sequel 4.49.0 → 5.3.0

data/lib/sequel/extensions/schema_dumper.rb

@@ -70,7 +70,7 @@ module Sequel
     end
 
     # Dump foreign key constraints for all tables as a migration. This complements
-    # the :foreign_keys=>false option to dump_schema_migration. This only dumps
+    # the foreign_keys: false option to dump_schema_migration. This only dumps
     # the constraints (not the columns) using alter_table/add_foreign_key with an
     # array of columns.
     #
@@ -81,14 +81,14 @@ module Sequel
       <<END_MIG
 Sequel.migration do
   change do
-#{ts.sort_by(&:to_s).map{|t| dump_table_foreign_keys(t)}.reject{|x| x == ''}.join("\n\n").gsub(/^/, '    ')}
+#{ts.sort.map{|t| dump_table_foreign_keys(t)}.reject{|x| x == ''}.join("\n\n").gsub(/^/, '    ')}
   end
 end
 END_MIG
     end
 
     # Dump indexes for all tables as a migration.  This complements
-    # the :indexes=>false option to dump_schema_migration. Options:
+    # the indexes: false option to dump_schema_migration. Options:
     # :same_db :: Create a dump for the same database type, so
     #             don't ignore errors if the index statements fail.
     # :index_names :: If set to false, don't record names of indexes. If
@@ -99,13 +99,13 @@ END_MIG
       <<END_MIG
 Sequel.migration do
   change do
-#{ts.sort_by(&:to_s).map{|t| dump_table_indexes(t, :add_index, options)}.reject{|x| x == ''}.join("\n\n").gsub(/^/, '    ')}
+#{ts.sort.map{|t| dump_table_indexes(t, :add_index, options)}.reject{|x| x == ''}.join("\n\n").gsub(/^/, '    ')}
   end
 end
 END_MIG
     end
 
-    # Return a string that contains a Sequel::Migration subclass that when
+    # Return a string that contains a Sequel migration that when
     # run would recreate the database structure. Options:
     # :same_db :: Don't attempt to translate database types to ruby types.
     #             If this isn't set to true, all database types will be translated to
@@ -132,7 +132,7 @@ END_MIG
         # Handle skipped foreign keys by adding them at the end via
         # alter_table/add_foreign_key.  Note that skipped foreign keys
         # probably result in a broken down migration.
-        sfka = sfk.sort_by{|table, fks| table.to_s}.map{|table, fks| dump_add_fk_constraints(table, fks.values)}
+        sfka = sfk.sort.map{|table, fks| dump_add_fk_constraints(table, fks.values)}
         sfka.join("\n\n").gsub(/^/, '    ') unless sfka.empty?
       end
 
@@ -225,7 +225,7 @@ END_MIG
       sfks = String.new
       sfks << "alter_table(#{table.inspect}) do\n"
       sfks << create_table_generator do
-        fks.sort_by{|fk| fk[:columns].map(&:to_s)}.each do |fk|
+        fks.sort_by{|fk| fk[:columns]}.each do |fk|
           foreign_key fk[:columns], fk
         end
       end.dump_constraints.gsub(/^foreign_key /, '  add_foreign_key ')
@@ -236,7 +236,7 @@ END_MIG
     # string that would add the foreign keys if run in a migration.
     def dump_table_foreign_keys(table, options=OPTS)
       if supports_foreign_key_parsing?
-        fks = foreign_key_list(table, options).sort_by{|fk| fk[:columns].map(&:to_s)}
+        fks = foreign_key_list(table, options).sort_by{|fk| fk[:columns]}
       end
 
       if fks.nil? || fks.empty?
@@ -256,7 +256,7 @@ END_MIG
       im = method(:index_to_generator_opts)
 
       if options[:indexes] != false && supports_index_parsing?
-        indexes = indexes(table).sort_by{|k,v| k.to_s}
+        indexes = indexes(table).sort
       end
 
       if options[:foreign_keys] != false && supports_foreign_key_parsing?
@@ -296,7 +296,7 @@ END_MIG
     # creating the index migration.
     def dump_table_indexes(table, meth, options=OPTS)
       if supports_index_parsing?
-        indexes = indexes(table).sort_by{|k,v| k.to_s}
+        indexes = indexes(table).sort
       else
         return ''
       end
@@ -335,7 +335,7 @@ END_MIG
         options[:skipped_foreign_keys] = skipped_foreign_keys
         tables
       else
-        tables.sort_by(&:to_s)
+        tables.sort
       end
     end
 
@@ -360,14 +360,14 @@ END_MIG
           # outstanding foreign keys and skipping those foreign keys.
           # The skipped foreign keys will be added at the end of the
           # migration.
-          skip_table, skip_fks = table_fks.sort_by{|table, fks| [fks.length, table.to_s]}.first
+          skip_table, skip_fks = table_fks.sort_by{|table, fks| [fks.length, table]}.first
           skip_fks_hash = skipped_foreign_keys[skip_table] = {}
           skip_fks.each{|fk| skip_fks_hash[fk[:columns]] = fk}
           this_loop << skip_table
         end
 
         # Add sorted tables from this loop to the final list
-        sorted_tables.concat(this_loop.sort_by(&:to_s))
+        sorted_tables.concat(this_loop.sort)
 
         # Remove tables that were handled this loop
         this_loop.each{|t| table_fks.delete(t)}

data/lib/sequel/extensions/select_remove.rb

@@ -1,6 +1,6 @@
 # frozen-string-literal: true
 #
-# The select_remove extension adds Sequel::Dataset#select_remove for removing existing selected
+# The select_remove extension adds select_remove for removing existing selected
 # columns from a dataset.  It's not part of Sequel core as it is rarely needed and has
 # some corner cases where it can't work correctly.
 #
@@ -26,8 +26,8 @@ module Sequel
     #   # Assume columns a, b, and c in items table
     #   DB[:items] # SELECT * FROM items
     #   DB[:items].select_remove(:c) # SELECT a, b FROM items
-    #   DB[:items].select(:a, :b___c, :c___b).select_remove(:c) # SELECT a, c AS b FROM items
-    #   DB[:items].select(:a, :b___c, :c___b).select_remove(:c___b) # SELECT a, b AS c FROM items
+    #   DB[:items].select(:a, Sequel[:b].as(:c), Sequel[:c].as(:b)).select_remove(:c) # SELECT a, c AS b FROM items
+    #   DB[:items].select(:a, Sequel[:b][:c], Sequel[:c][:b]).select_remove(Sequel[:c][:b]) # SELECT a, b AS c FROM items
     #
     # Note that there are a few cases where this method may not work correctly:
     #

data/lib/sequel/extensions/split_array_nil.rb

@@ -3,7 +3,7 @@
 # The split_array_nil extension overrides Sequel's default handling of
 # IN/NOT IN with arrays of values to do specific nil checking.  For example,
 #
-#   ds = DB[:table].where(:column=>[1, nil])
+#   ds = DB[:table].where(column: [1, nil])
 # 
 # By default, that produces the following SQL:
 #
@@ -19,7 +19,7 @@
 #
 # Similarly, for NOT IN queries:
 #
-#   ds = DB[:table].exclude(:column=>[1, nil])
+#   ds = DB[:table].exclude(column: [1, nil])
 #   # Default:
 #   #   SELECT * FROM table WHERE (column NOT IN (1, NULL))
 #   # with split_array_nils extension:

data/lib/sequel/extensions/sql_comments.rb

@@ -20,7 +20,7 @@
 # work correctly when used in subqueries:
 #
 #   ds = DB[:table].comment("Some\r\nComment     Here")
-#   ds.where(:id=>ds).all
+#   ds.where(id: ds).all
 #   # SELECT * FROM table WHERE (id IN (SELECT * FROM table -- Some Comment Here
 #   # )) -- Some Comment Here
 #   #
@@ -31,7 +31,7 @@
 # Due to the use of single line SQL comments and converting all
 # whitespace to spaces, this should correctly handle even
 # malicious input.  However, it would be unwise to rely on that,
-# you should probably attempt to ensure that the argument given
+# you should ensure that the argument given
 # to Dataset#comment is not derived from user input.
 #
 # You can load this extension into specific datasets:

data/lib/sequel/extensions/string_agg.rb

@@ -103,8 +103,7 @@ module Sequel
               f = f.distinct
             end
             literal_append(sql, f)
-          # SEQUEL5: Remove cubrid
-          when :mysql, :hsqldb, :cubrid, :h2
+          when :mysql, :hsqldb, :h2
             sql << "GROUP_CONCAT("
             if distinct
               sql << "DISTINCT "
@@ -148,6 +147,8 @@ module Sequel
       def initialize(expr, separator=nil)
         @expr = expr
         @separator = separator
+        yield self if block_given?
+        freeze
       end
 
       # Whether the current expression uses distinct expressions 
@@ -157,16 +158,18 @@ module Sequel
 
       # Return a modified StringAgg that uses distinct expressions
       def distinct
-        sa = dup
-        sa.instance_variable_set(:@distinct, true)
-        sa
+        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)
-        sa = dup
-        sa.instance_variable_set(:@order_expr, o.empty? ? nil : o)
-        sa
+        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

data/lib/sequel/extensions/symbol_aref.rb

@@ -41,26 +41,12 @@ else
       alias_method :aref_before_sequel, :[] 
     end
 
-    if RUBY_VERSION >= '1.9'
-      # 
-      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
-    else
-      def [](*v)
-        arg = v.first if v.length == 1
-
-        case arg
-        when Symbol, Sequel::SQL::Identifier, Sequel::SQL::QualifiedIdentifier
-          Sequel::SQL::QualifiedIdentifier.new(self, arg)
-        else
-          respond_to?(:aref_before_sequel) ? aref_before_sequel(*v) : super(*v)
-        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

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