sequel 4.34.0 → 4.35.0

data/lib/sequel/extensions/server_logging.rb

@@ -0,0 +1,61 @@
+# frozen-string-literal: true
+#
+# The server_logging extension makes the logger include the server/shard
+# the query was issued on.  This makes it easier to use the logs when
+# using sharding.
+#
+# Example:
+#
+#   DB.opts[:server]
+#   # {:read_only=>{}, :b=>{}}
+#   DB.extension :server_logging
+#   DB[:a].all
+#   # (0.000005s) (conn: 1014942550, server: read_only) SELECT * FROM a
+#   DB[:a].server(:b).all
+#   # (0.000004s) (conn: 997304100, server: b) SELECT * FROM a
+#   DB[:a].insert
+#   # (0.000004s) (conn: 1014374750, server: default) INSERT INTO a DEFAULT VALUES
+#
+# In order for the server/shard to be correct for all connections, you need to
+# use this before connections to the database are made, or you need to call
+# <tt>Database#disconnect</tt> after loading this extension.
+#
+# Related module: Sequel::ServerLogging
+
+#
+module Sequel
+  module ServerLogging
+    # Initialize the hash mapping connections to shards, and turn on logging
+    # of connection info unless it has specifically been turned off.
+    def self.extended(db)
+      db.instance_exec do
+        @server_connection_map ||= {}
+        self.log_connection_info = true if log_connection_info.nil?
+      end
+    end
+
+    # When setting up a new connection, associate the connection with the
+    # shard.
+    def connect(server)
+      conn = super
+      Sequel.synchronize{@server_connection_map[conn] = server}
+      conn
+    end
+
+    # When disconnecting a connection, remove the related connection from the mapping.
+    def disconnect_connection(conn)
+      super
+    ensure
+      Sequel.synchronize{@server_connection_map.delete(conn)}
+    end
+
+    private
+
+    # Include the server with the connection's id.
+    def connection_info(conn)
+      "(conn: #{conn.__id__}, server: #{Sequel.synchronize{@server_connection_map[conn]}}) "
+    end
+  end
+
+  Database.register_extension(:server_logging, ServerLogging)
+end

data/lib/sequel/extensions/sql_comments.rb

@@ -0,0 +1,91 @@
+# frozen-string-literal: true
+#
+# The sql_comments extension adds Dataset#comment to the datasets,
+# allowing you to set SQL comments in the resulting query.  These
+# comments are appended to the end of the SQL query:
+#
+#   ds = DB[:table].comment("Some Comment").all
+#   # SELECT * FROM table -- Some Comment
+#   #
+#
+# As you can see, this uses single line SQL comments (--) suffixed
+# by a newline.  This # plugin transforms all consecutive
+# whitespace in the comment to # a single string:
+#
+#   ds = DB[:table].comment("Some\r\nComment     Here").all
+#   # SELECT * FROM table -- Some Comment Here
+#   #
+#
+# The reason for the prefixing and suffixing by newlines is to
+# work correctly when used in subqueries:
+#
+#   ds = DB[:table].comment("Some\r\nComment     Here")
+#   ds.where(:id=>ds).all
+#   # SELECT * FROM table WHERE (id IN (SELECT * FROM table -- Some Comment Here
+#   # )) -- Some Comment Here
+#   #
+#
+# In addition to working on SELECT queries, it also works when
+# inserting, updating, and deleting.
+#
+# 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
+# to Dataset#comment is not derived from user input.
+#
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds = ds.extension(:sql_comments)
+#
+# 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(:sql_comments)
+#
+# Note that Microsoft Access does not support inline comments,
+# and attempting to use comments on it will result in SQL syntax
+# errors.
+#
+# Related module: Sequel::SQLComments
+
+#
+module Sequel
+  module SQLComments
+    # Return a modified copy of the dataset that will use the given comment.
+    # To uncomment a commented dataset, pass nil as the argument.
+    def comment(comment)
+      clone(:comment=>(format_sql_comment(comment) if comment))
+    end
+
+    %w'select insert update delete'.each do |type|
+      define_method(:"#{type}_sql") do |*a|
+        sql = super(*a)
+        if comment = @opts[:comment]
+          # This assumes that the comment stored in the dataset has
+          # already been formatted. If not, this could result in SQL
+          # injection.
+          #
+          # Additionally, due to the use of an SQL comment, if any
+          # SQL is appened to the query after the comment is added,
+          # it will become part of the comment unless it is preceded
+          # by a newline.
+          sql << comment
+        end
+        sql
+      end
+    end
+
+    private
+
+    # Format the comment.  For maximum compatibility, this uses a
+    # single line SQL comment, and converts all consecutive whitespace
+    # in the comment to a single space.
+    def format_sql_comment(comment)
+      " -- #{comment.to_s.gsub(/\s+/, ' ')}\n"
+    end
+  end
+
+  Dataset.register_extension(:sql_comments, SQLComments)
+end

data/lib/sequel/model/associations.rb

@@ -2194,14 +2194,7 @@ module Sequel
 
         # Add the given associated object to the given association
         def add_associated_object(opts, o, *args)
-          klass = opts.associated_class
-          if o.is_a?(Hash)
-            o = klass.new(o)
-          elsif o.is_a?(Integer) || o.is_a?(String) || o.is_a?(Array)
-            o = klass.with_pk!(o)
-          elsif !o.is_a?(klass)
-            raise(Sequel::Error, "associated object #{o.inspect} not of correct type #{klass}")
-          end
+          o = make_add_associated_object(opts, o)
           raise(Sequel::Error, "model object #{inspect} does not have a primary key") if opts.dataset_need_primary_key? && !pk
           ensure_associated_primary_key(opts, o, *args)
           return if run_association_callbacks(opts, :before_add, o) == false
@@ -2317,6 +2310,25 @@ module Sequel
             opts.send(:cached_fetch, :many_to_one_pk_lookup){opts.primary_key == opts.associated_class.primary_key}
         end
         
+        # Convert the input of the add_* association method into an associated object. For
+        # hashes, this creates a new object using the hash.  For integers, strings, and arrays,
+        # assume the value specifies a primary key, and lookup an existing object with that primary key.
+        # Otherwise, if the object is not already an instance of the class, raise an exception.
+        def make_add_associated_object(opts, o)
+          klass = opts.associated_class
+
+          case o
+          when Hash
+            klass.new(o)
+          when Integer, String, Array
+            klass.with_pk!(o)
+          when klass
+            o
+          else 
+            raise(Sequel::Error, "associated object #{o.inspect} not of correct type #{klass}")
+          end
+        end
+
         # Remove all associated objects from the given association
         def remove_all_associated_objects(opts, *args)
           raise(Sequel::Error, "model object #{inspect} does not have a primary key") if opts.dataset_need_primary_key? && !pk
@@ -2650,6 +2662,26 @@ END
           end
         end
 
+        # If the dataset is being eagerly loaded, default to calling all
+        # instead of each.
+        def to_hash(key_column=nil, value_column=nil, opts=OPTS)
+          if (@opts[:eager_graph] || @opts[:eager]) && !opts.has_key?(:all)
+            opts = Hash[opts]
+            opts[:all] = true
+          end
+          super
+        end
+
+        # If the dataset is being eagerly loaded, default to calling all
+        # instead of each.
+        def to_hash_groups(key_column, value_column=nil, opts=OPTS)
+          if (@opts[:eager_graph] || @opts[:eager]) && !opts.has_key?(:all)
+            opts = Hash[opts]
+            opts[:all] = true
+          end
+          super
+        end
+
         # Do not attempt to split the result set into associations,
         # just return results as simple objects.  This is useful if you
         # want to use eager_graph as a shortcut to have all of the joins

data/lib/sequel/model/base.rb

@@ -1402,17 +1402,31 @@ module Sequel
         @values.keys
       end
       
-      # Refresh this record using +for_update+ unless this is a new record.  Returns self.
-      # This can be used to make sure no other process is updating the record at the
-      # same time.
+      # Refresh this record using +for_update+ (by default, or the specified style when given)
+      # unless this is a new record.  Returns self. This can be used to make sure no other
+      # process is updating the record at the same time.
+      #
+      # If style is a string, it will be used directly. You should never pass a string
+      # to this method that is derived from user input, as that can lead to
+      # SQL injection.
+      #
+      # A symbol may be used for database independent locking behavior, but
+      # all supported symbols have separate methods (e.g. for_update).
+      #
       #
       #   a = Artist[1]
       #   Artist.db.transaction do
       #     a.lock!
       #     a.update(:name=>'A')
       #   end
-      def lock!
-        _refresh(this.for_update) unless new?
+      #
+      #  a = Artist[2]
+      #  Artist.db.transaction do
+      #    a.lock!('FOR NO KEY UPDATE')
+      #    a.update(:name=>'B')
+      #  end
+      def lock!(style=:update)
+        _refresh(this.lock_style(style)) unless new?
         self
       end
       

data/lib/sequel/plugins/class_table_inheritance.rb

@@ -84,6 +84,18 @@ module Sequel
     #   a.values # {:id=>1, name=>'S', :kind=>'CEO'}
     #   a.refresh.values # {:id=>1, name=>'S', :kind=>'Executive', :num_staff=>4, :num_managers=>2}
     #
+    # You can also load directly from a subclass:
+    #
+    #   a = Executive.first
+    #   a.values # {:id=>1, name=>'S', :kind=>'Executive', :num_staff=>4, :num_managers=>2}
+    #   
+    # Note that when loading from a subclass, because the subclass dataset uses a JOIN,
+    # if you are referencing the primary key column, you need to disambiguate the reference
+    # by explicitly qualifying it:
+    #
+    #   a = Executive.where(:id=>1).first # database error
+    #   a = Executive.where(:executives__id=>1).first # no error
+    #
     # = Usage
     #
     #   # Use the default of storing the class name in the sti_key

data/lib/sequel/plugins/delay_add_association.rb

@@ -38,6 +38,7 @@ module Sequel
         # current object.
         def add_associated_object(opts, o, *args)
           if opts.dataset_need_primary_key? && new?
+            o = make_add_associated_object(opts, o)
             delay_validate_associated_object(opts, o)
             send(opts[:name]) << o
             after_create_hook{super(opts, o, *args)}

data/lib/sequel/plugins/json_serializer.rb

@@ -300,8 +300,16 @@ module Sequel
             if inc.is_a?(Hash)
               inc.each do |k, v|
                 v = v.empty? ? [] : [v]
-                h[k.to_s] = case objs = send(k)
-                when Array
+
+                objs = send(k)
+
+                is_array = if r = model.association_reflection(k)
+                  r.returns_array?
+                else
+                  objs.is_a?(Array)
+                end
+                
+                h[k.to_s] = if is_array
                   objs.map{|obj| Literal.new(Sequel.object_to_json(obj, *v))}
                 else
                   Literal.new(Sequel.object_to_json(objs, *v))

data/lib/sequel/version.rb

@@ -5,7 +5,7 @@ module Sequel
   MAJOR = 4
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 34
+  MINOR = 35
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapter_spec.rb

@@ -0,0 +1,4 @@
+if !ARGV.empty? && ARGV.first != 'none'
+  require "./spec/adapters/#{ARGV.first}_spec.rb"
+end
+Dir['./spec/integration/*_test.rb'].each{|f| require f}

data/spec/adapters/mysql_spec.rb

@@ -528,7 +528,7 @@ describe "A MySQL database" do
 
   it "should have set_column_type support keep existing options" do
     @db.create_table(:items){Integer :id, :null=>false, :default=>5}
-    @db.alter_table(:items){set_column_type :id, Bignum}
+    @db.alter_table(:items){set_column_type :id, :Bignum}
     check_sqls do
       @db.sqls.must_equal ["CREATE TABLE `items` (`id` integer NOT NULL DEFAULT 5)", "DESCRIBE `items`", "ALTER TABLE `items` CHANGE COLUMN `id` `id` bigint NOT NULL DEFAULT 5"]
     end

data/spec/adapters/postgres_spec.rb

@@ -945,7 +945,7 @@ describe "A PostgreSQL database" do
     @db.create_table!(:posts){primary_key :a, :type=>Fixnum}
     @db[:posts].insert.must_equal 1
     @db[:posts].insert.must_equal 2
-    @db.create_table!(:posts){primary_key :a, :type=>Bignum}
+    @db.create_table!(:posts){primary_key :a, :type=>:Bignum}
     @db[:posts].insert.must_equal 1
     @db[:posts].insert.must_equal 2
   end
@@ -973,6 +973,7 @@ describe "A PostgreSQL database" do
     @db[:posts].insert(:title=>'ruby scooby', :body=>'x')
 
     @db[:posts].full_text_search(:title, 'rails').all.must_equal [{:title=>'ruby rails', :body=>'yowsa'}]
+    @db[:posts].full_text_search(:title, 'rails', :headline=>true).all.must_equal [{:title=>'ruby rails', :body=>'yowsa', :headline=>'ruby <b>rails</b>'}]
     @db[:posts].full_text_search([:title, :body], ['yowsa', 'rails']).all.must_equal [:title=>'ruby rails', :body=>'yowsa']
     @db[:posts].full_text_search(:title, 'scooby', :language => 'french').all.must_equal [{:title=>'ruby scooby', :body=>'x'}]
 
@@ -997,7 +998,7 @@ describe "A PostgreSQL database" do
     @db[:posts].insert(:title=>t1)
     @db[:posts].insert(:title=>t2)
     @db[:posts].full_text_search(:title, 'ruby & sequel', :rank=>true).select_map(:title).must_equal [t2, t1]
-  end
+  end if DB.server_version >= 80300
 
   it "should support spatial indexes" do
     @db.create_table(:posts){box :geom; spatial_index [:geom]}

data/spec/core/connection_pool_spec.rb

@@ -8,6 +8,8 @@ mock_db = lambda do |*a, &b|
   if b2 = a.shift
     (class << db; self end).send(:define_method, :disconnect_connection){|c| b2.arity == 1 ? b2.call(c) : b2.call}
   end
+  # Work around JRuby Issue #3854
+  (class << db; self end).send(:public, :connect, :disconnect_connection)
   db
 end
 

data/spec/core/database_spec.rb

@@ -341,6 +341,35 @@ describe "Database#log_yield" do
   end
 end
 
+describe "Database#log_connection_yield" do
+  before do
+    @o = Object.new
+    def @o.logs; @logs || []; end
+    def @o.to_ary; [self]; end
+    def @o.method_missing(*args); (@logs ||= []) << args; end
+    @conn = Object.new
+    @db = Sequel::Database.new(:logger=>@o)
+  end
+
+  it "should log SQL to the loggers" do
+    @db.log_connection_yield("some SQL", @conn){}
+    @o.logs.length.must_equal 1
+    @o.logs.first.length.must_equal 2
+    @o.logs.first.first.must_equal :info
+    @o.logs.first.last.must_match(/some SQL\z/)
+    @o.logs.first.last.wont_match(/\(conn: -?\d+\) some SQL\z/)
+  end
+
+  it "should include connection information when logging" do
+    @db.log_connection_info = true
+    @db.log_connection_yield("some SQL", @conn){}
+    @o.logs.length.must_equal 1
+    @o.logs.first.length.must_equal 2
+    @o.logs.first.first.must_equal :info
+    @o.logs.first.last.must_match(/\(conn: -?\d+\) some SQL\z/)
+  end
+end
+
 describe "Database#uri" do
   before do
     @c = Class.new(Sequel::Database) do
@@ -993,6 +1022,15 @@ describe "Database#transaction with savepoint support" do
     a.must_equal [1, 1]
   end
   
+  it "should automatically use a savepoint if :rollback=>:always given inside a transaction" do
+    @db.transaction do
+      @db.transaction(:rollback=>:always) do
+        @db.get(1)
+      end
+    end
+    @db.sqls.must_equal ["BEGIN", "SAVEPOINT autopoint_1", "SELECT 1 AS v LIMIT 1", "ROLLBACK TO SAVEPOINT autopoint_1", "COMMIT"]
+  end
+  
   it "should support :retry_on option for automatically retrying transactions inside an :auto_savepoint transaction" do
     a = []
     @db.transaction(:auto_savepoint=>true) do
@@ -1058,6 +1096,17 @@ describe "Database#transaction without savepoint support" do
     @db.sqls.must_equal ['BEGIN', 'COMMIT']
   end
 
+  it "should automatically use a savepoint if :rollback=>:always given inside a transaction" do
+    proc do
+      @db.transaction do
+        @db.transaction(:rollback=>:always) do
+          @db.get(1)
+        end
+      end
+    end.must_raise Sequel::Error
+    @db.sqls.must_equal ["BEGIN", "ROLLBACK"]
+  end
+  
   include DatabaseTransactionSpecs
 end
   

data/spec/core/dataset_spec.rb

@@ -1822,10 +1822,17 @@ describe "Dataset#to_hash_groups" do
     @d.to_hash_groups([:a, :b]).must_equal([1, 2] => [{:a => 1, :b => 2}], [3, 4] => [{:a => 3, :b => 4}], [1, 6] => [{:a => 1, :b => 6}], [7, 4] => [{:a => 7, :b => 4}])
   end
 
-  it "should accept an optional :hash parameter into which entries can be merged" do
+  it "should accept a :hash option into which entries can be merged" do
     @d.to_hash_groups(:a, :b, :hash => (tmp = {})).must_be_same_as(tmp)
   end
 
+  it "should accept an :all option to use all into which entries can be merged" do
+    called = false
+    meta_def(@d, :post_load){|_| called = true}
+    @d.to_hash_groups(:a, :b, :all=>true)
+    called.must_equal true
+  end
+
   it "should not call the row_proc if two arguments are given" do
     @d.row_proc = proc{|r| h = {}; r.keys.each{|k| h[k] = r[k] * 2}; h}
     @d.to_hash_groups(:a, :b).must_equal(1 => [2, 6], 3 => [4], 7 => [4])
@@ -4534,6 +4541,23 @@ describe "Dataset#lock_style and for_update" do
   end
 end
 
+describe "Dataset#skip_locked" do
+  before do
+    @ds = Sequel.mock.dataset.from(:t).for_update
+  end
+  
+  it "should raise an error if not supported" do
+    proc{@ds.skip_locked}.must_raise Sequel::Error
+  end
+  
+  it "should skipped locked rows if supported" do
+    def @ds.supports_skip_locked?; true end
+    def @ds.select_lock_sql(sql) super; sql << " SKIP LOCKED" if @opts[:skip_locked] end
+    @ds.sql.must_equal "SELECT * FROM t FOR UPDATE"
+    @ds.skip_locked.sql.must_equal "SELECT * FROM t FOR UPDATE SKIP LOCKED"
+  end
+end
+  
 describe "Custom ASTTransformer" do
   it "should transform given objects" do
     c = Class.new(Sequel::ASTTransformer) do