sequel 4.26.0 → 5.37.0

data/lib/sequel/extensions/select_remove.rb

@@ -1,4 +1,6 @@
-# The select_remove extension adds Sequel::Dataset#select_remove for removing existing selected
+# frozen-string-literal: true
+#
+# 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.
 #
@@ -11,6 +13,8 @@
 # is probably the desired behavior if you are using this extension:
 #
 #   DB.extension(:select_remove)
+#
+# Related module: Sequel::SelectRemove
 
 #
 module Sequel
@@ -22,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:
     #
@@ -31,7 +35,7 @@ module Sequel
     #   In this case, the code will currently use unqualified column names for all columns
     #   the dataset returns, except for the columns given.
     # * This dataset has an existing explicit selection containing an item that returns
-    #   multiple database columns (e.g. Sequel.expr(:table).*, Sequel.lit('column1, column2')).  In this case,
+    #   multiple database columns (e.g. Sequel[:table].*, Sequel.lit('column1, column2')).  In this case,
     #   the behavior is undefined and this method should not be used.
     #
     # There may be other cases where this method does not work correctly, use it with caution.

data/lib/sequel/extensions/sequel_4_dataset_methods.rb

@@ -0,0 +1,85 @@
+# frozen-string-literal: true
+#
+# This adds the following dataset methods:
+#
+# and :: alias for where
+# exclude_where :: alias for exclude
+# interval :: Returns max - min, using a single query
+# range :: Returns min..max, using a single query
+#
+# It is only recommended to use this for backwards compatibility.
+#
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds = ds.extension(:sequel_4_dataset_methods)
+#
+# 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(:sequel_4_dataset_methods)
+#
+# Related module: Sequel::Sequel4DatasetMethods
+
+#
+module Sequel
+  module Sequel4DatasetMethods
+    # Alias for where.
+    def and(*cond, &block)
+      where(*cond, &block)
+    end
+    
+    # Alias for exclude.
+    def exclude_where(*cond, &block)
+      exclude(*cond, &block)
+    end
+
+    # Returns the interval between minimum and maximum values for the given 
+    # column/expression. Uses a virtual row block if no argument is given.
+    #
+    #   DB[:table].interval(:id) # SELECT (max(id) - min(id)) FROM table LIMIT 1
+    #   # => 6
+    #   DB[:table].interval{function(column)} # SELECT (max(function(column)) - min(function(column))) FROM table LIMIT 1
+    #   # => 7
+    def interval(column=(no_arg = true), &block)
+      column = Sequel.virtual_row(&block) if no_arg
+      if loader = cached_placeholder_literalizer(:_interval_loader) do |pl|
+          arg = pl.arg
+          aggregate_dataset.limit(1).select((SQL::Function.new(:max, arg) - SQL::Function.new(:min, arg)).as(:interval))
+        end
+
+        loader.get(column)
+      else
+        aggregate_dataset.get{(max(column) - min(column)).as(:interval)}
+      end
+    end
+
+    # Returns a +Range+ instance made from the minimum and maximum values for the
+    # given column/expression.  Uses a virtual row block if no argument is given.
+    #
+    #   DB[:table].range(:id) # SELECT max(id) AS v1, min(id) AS v2 FROM table LIMIT 1
+    #   # => 1..10
+    #   DB[:table].interval{function(column)} # SELECT max(function(column)) AS v1, min(function(column)) AS v2 FROM table LIMIT 1
+    #   # => 0..7
+    def range(column=(no_arg = true), &block)
+      column = Sequel.virtual_row(&block) if no_arg
+      r = if loader = cached_placeholder_literalizer(:_range_loader) do |pl|
+            arg = pl.arg
+            aggregate_dataset.limit(1).select(SQL::Function.new(:min, arg).as(:v1), SQL::Function.new(:max, arg).as(:v2))
+          end
+
+        loader.first(column)
+      else
+        aggregate_dataset.select{[min(column).as(v1), max(column).as(v2)]}.first
+      end
+
+      if r
+        (r[:v1]..r[:v2])
+      end
+    end
+    
+  end
+
+  Dataset.register_extension(:sequel_4_dataset_methods, Sequel4DatasetMethods)
+end
+

data/lib/sequel/extensions/server_block.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+#
 # The server_block extension adds the Database#with_server method, which takes a shard
 # argument and a block, and makes it so that access inside the block will use the
 # specified shard by default.
@@ -14,7 +16,7 @@
 #   end
 #   DB[:a].all # Uses default
 #
-# You can even nest calls to with_server:
+# You can nest calls to with_server:
 #
 #   DB.with_server(:shard1) do
 #     DB[:a].all # Uses shard1
@@ -36,6 +38,28 @@
 #     DB[:a].server(:default).all # Uses shard1
 #     DB[:a].server(:read_only).all # Uses shard1
 #   end
+#
+# If you pass two separate shards to with_server, the second shard will
+# be used instead of the :read_only shard, and the first shard will be
+# used instead of the :default shard:
+#
+#   DB.with_server(:shard1, :shard2) do
+#     DB[:a].all # Uses shard2
+#     DB[:a].delete # Uses shard1
+#     DB[:a].server(:shard3).all # Uses shard3
+#     DB[:a].server(:shard3).delete # Uses shard3
+#     DB[:a].server(:default).all # Uses shard1
+#     DB[:a].server(:read_only).delete # Uses shard2
+#   end
+#
+# If you use an invalid server when calling with_server, it will be
+# treated the same way as if you called Dataset#server with an invalid
+# server.  By default, the default server will be used in such cases.
+# If you would like a different server to be used, or an exception to
+# be raised, then use the :servers_hash Database option.
+#
+# Related modules: Sequel::ServerBlock, Sequel::UnthreadedServerBlock,
+# Sequel::ThreadedServerBlock
 
 #
 module Sequel
@@ -55,17 +79,17 @@ module Sequel
     end
 
     # Delegate to the connection pool
-    def with_server(server, &block)
-      pool.with_server(server, &block)
+    def with_server(default_server, read_only_server=default_server, &block)
+      pool.with_server(default_server, read_only_server, &block)
     end
   end
 
   # Adds with_server support for the sharded single connection pool.
   module UnthreadedServerBlock
     # Set a default server/shard to use inside the block.
-    def with_server(server)
+    def with_server(default_server, read_only_server=default_server)
       begin
-        set_default_server(server)
+        set_default_server(default_server, read_only_server)
         yield
       ensure
         clear_default_server
@@ -75,8 +99,8 @@ module Sequel
     private
 
     # Make the given server the new default server.
-    def set_default_server(server)
-      @default_servers << server
+    def set_default_server(default_server, read_only_server=default_server)
+      @default_servers << [default_server, read_only_server]
     end
 
     # Remove the current default server, restoring the
@@ -91,8 +115,10 @@ module Sequel
         super
       else
         case server
-        when :default, nil, :read_only
-          @default_servers.last
+        when :default, nil
+          @servers[@default_servers[-1][0]]
+        when :read_only
+          @servers[@default_servers[-1][1]]
         else
           super
         end
@@ -104,9 +130,9 @@ module Sequel
   module ThreadedServerBlock
     # Set a default server/shard to use inside the block for the current
     # thread.
-    def with_server(server)
+    def with_server(default_server, read_only_server=default_server)
       begin
-        set_default_server(server)
+        set_default_server(default_server, read_only_server)
         yield
       ensure
         clear_default_server
@@ -116,14 +142,14 @@ module Sequel
     private
 
     # Make the given server the new default server for the current thread.
-    def set_default_server(server)
-      sync{(@default_servers[Thread.current] ||= [])} << server
+    def set_default_server(default_server, read_only_server=default_server)
+      sync{(@default_servers[Sequel.current] ||= [])} << [default_server, read_only_server]
     end
 
     # Remove the current default server for the current thread, restoring the
     # previous default server.
     def clear_default_server
-      t = Thread.current
+      t = Sequel.current
       a = sync{@default_servers[t]}
       a.pop
       sync{@default_servers.delete(t)} if a.empty?
@@ -131,13 +157,20 @@ module Sequel
 
     # Use the server given to with_server for the given thread, if appropriate.
     def pick_server(server)
-      a = sync{@default_servers[Thread.current]}
+      a = sync{@default_servers[Sequel.current]}
       if !a || a.empty?
         super
       else
+        # Hash handling required to work when loaded after arbitrary servers plugin.
         case server
-        when :default, nil, :read_only
-          a.last
+        when :default, nil
+          v = a[-1][0]
+          v = @servers[v] unless v.is_a?(Hash)
+          v
+        when :read_only
+          v = a[-1][1]
+          v = @servers[v] unless v.is_a?(Hash)
+          v
         else
           super
         end

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

@@ -1,7 +1,9 @@
+# frozen-string-literal: true
+#
 # 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:
 #
@@ -17,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:
@@ -30,6 +32,8 @@
 # To use this extension for all of a database's datasets:
 #
 #   DB.extension(:split_array_nil)
+#
+# Related module: Sequel::Dataset::SplitArrayNil
 
 #
 module Sequel
@@ -42,9 +46,9 @@ module Sequel
       def complex_expression_sql_append(sql, op, args)
       case op
       when :IN, :"NOT IN"
-        vals = args.at(1)
+        vals = args[1]
         if vals.is_a?(Array) && vals.any?(&:nil?)
-          cols = args.at(0)
+          cols = args[0]
           vals = vals.compact
           c = Sequel::SQL::BooleanExpression
           if op == :IN

data/lib/sequel/extensions/sql_comments.rb

@@ -0,0 +1,96 @@
+# 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 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.
+          if sql.frozen?
+            sql += comment
+            sql.freeze
+          else
+            sql << comment
+          end
+        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