sequel 3.21.0 → 3.41.0

data/lib/sequel/extensions/server_block.rb

@@ -0,0 +1,140 @@
+# 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.
+#
+# First, you need to enable it on the database object:
+#
+#   DB.extension :server_block
+# 
+# Then you can call with_server:
+#
+#   DB.with_server(:shard1) do
+#     DB[:a].all # Uses shard1
+#     DB[:a].server(:shard2).all # Uses shard2
+#   end
+#   DB[:a].all # Uses default
+#
+# You can even nest calls to with_server:
+#
+#   DB.with_server(:shard1) do
+#     DB[:a].all # Uses shard1
+#     DB.with_server(:shard2) do
+#       DB[:a].all # Uses shard2
+#     end
+#     DB[:a].all # Uses shard1
+#   end
+#   DB[:a].all # Uses default
+# 
+# Note this this extension assumes the following shard names should use the
+# server/shard passed to with_server: :default, nil, :read_only.  All other
+# shard names will cause the standard behavior to be used.
+
+module Sequel
+  module ServerBlock
+    # Enable the server block on the connection pool, choosing the correct
+    # extension depending on whether the connection pool is threaded or not.
+    # Also defines the with_server method on the receiver for easy use.
+    def self.extended(db)
+      pool = db.pool
+      if defined?(ShardedThreadedConnectionPool) && pool.is_a?(ShardedThreadedConnectionPool)
+        pool.extend(ThreadedServerBlock)
+        pool.instance_variable_set(:@default_servers, {})
+      else
+        pool.extend(UnthreadedServerBlock)
+        pool.instance_variable_set(:@default_servers, [])
+      end
+    end
+
+    # Delegate to the connection pool
+    def with_server(server, &block)
+      pool.with_server(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)
+      begin
+        set_default_server(server)
+        yield
+      ensure
+        clear_default_server
+      end
+    end
+
+    private
+
+    # Make the given server the new default server.
+    def set_default_server(server)
+      @default_servers << server
+    end
+
+    # Remove the current default server, restoring the
+    # previous default server.
+    def clear_default_server
+      @default_servers.pop
+    end
+
+    # Use the server given to with_server if appropriate.
+    def pick_server(server)
+      if @default_servers.empty?
+        super
+      else
+        case server
+        when :default, nil, :read_only
+          @default_servers.last
+        else
+          super
+        end
+      end
+    end
+  end
+
+  # Adds with_server support for the sharded threaded connection pool.
+  module ThreadedServerBlock
+    # Set a default server/shard to use inside the block for the current
+    # thread.
+    def with_server(server)
+      begin
+        set_default_server(server)
+        yield
+      ensure
+        clear_default_server
+      end
+    end
+
+    private
+
+    # Make the given server the new default server for the current thread.
+    def set_default_server(server)
+      sync{(@default_servers[Thread.current] ||= [])} << server
+    end
+
+    # Remove the current default server for the current thread, restoring the
+    # previous default server.
+    def clear_default_server
+      t = Thread.current
+      a = sync{@default_servers[t]}
+      a.pop
+      sync{@default_servers.delete(t)} if a.empty?
+    end
+
+    # Use the server given to with_server for the given thread, if appropriate.
+    def pick_server(server)
+      a = sync{@default_servers[Thread.current]}
+      if !a || a.empty?
+        super
+      else
+        case server
+        when :default, nil, :read_only
+          a.last
+        else
+          super
+        end
+      end
+    end
+  end
+
+  Database.register_extension(:server_block, ServerBlock)
+end

data/lib/sequel/extensions/split_array_nil.rb

@@ -0,0 +1,65 @@
+# 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])
+# 
+# By default, that produces the following SQL:
+#
+#   SELECT * FROM table WHERE (column IN (1, NULL))
+#
+# However, because NULL = NULL is not true in SQL (it is NULL), this
+# will not return rows in the table where the column is NULL.  This
+# extension allows for an alternative behavior more similar to ruby,
+# which will return rows in the table where the column is NULL, using
+# a query like:
+#
+#   SELECT * FROM table WHERE ((column IN (1)) OR (column IS NULL)))
+#
+# Similarly, for NOT IN queries:
+#
+#   ds = DB[:table].exclude(:column=>[1, nil])
+#   # Default:
+#   #   SELECT * FROM table WHERE (column NOT IN (1, NULL))
+#   # with split_array_nils extension:
+#   #   SELECT * FROM table WHERE ((column NOT IN (1)) AND (column IS NOT NULL)))
+#
+# To use this extension with a single dataset:
+#
+#   ds = ds.extension(:split_array_nil)
+#
+# To use this extension for all of a database's datasets:
+#
+#   DB.extension(:split_array_nil)
+
+module Sequel
+  class Dataset
+    module SplitArrayNil
+      # Over the IN/NOT IN handling with an array of values where one of the
+      # values in the array is nil, by removing nils from the array of values,
+      # and using a separate OR IS NULL clause for IN or AND IS NOT NULL clause
+      # for NOT IN.
+      def complex_expression_sql_append(sql, op, args)
+      case op
+      when :IN, :"NOT IN"
+        vals = args.at(1)
+        if vals.is_a?(Array) && vals.any?{|v| v.nil?}
+          cols = args.at(0)
+          vals = vals.compact
+          c = Sequel::SQL::BooleanExpression
+          if op == :IN
+            literal_append(sql, c.new(:OR, c.new(:IN, cols, vals), c.new(:IS, cols, nil)))
+          else
+            literal_append(sql, c.new(:AND, c.new(:"NOT IN", cols, vals), c.new(:"IS NOT", cols, nil)))
+          end
+        else
+          super
+        end
+      else
+        super
+      end
+      end
+    end
+  end
+
+  Dataset.register_extension(:split_array_nil, Dataset::SplitArrayNil)
+end

data/lib/sequel/extensions/sql_expr.rb

@@ -1,122 +1,20 @@
 # The sql_expr extension adds the sql_expr method to every object, which
-# returns an object that works nicely with Sequel's DSL.  This is
-# best shown by example:
+# returns an wrapped object that works nicely with Sequel's DSL by calling
+# Sequel.expr:
 #
 #   1.sql_expr < :a     # 1 < a
 #   false.sql_expr & :a # FALSE AND a
 #   true.sql_expr | :a  # TRUE OR a
 #   ~nil.sql_expr       # NOT NULL
 #   "a".sql_expr + "b"  # 'a' || 'b'
-
-module Sequel
-  module SQL
-    # The GenericComplexExpression acts like a 
-    # GenericExpression in terms of methods,
-    # but has an internal structure of a
-    # ComplexExpression.  It is used by Object#sql_expr.
-    # Since we don't know what specific type of object
-    # we are dealing with it, we treat it similarly to
-    # how we treat symbols or literal strings, allowing
-    # many different types of methods.
-    class GenericComplexExpression < ComplexExpression
-      include AliasMethods
-      include BooleanMethods
-      include CastMethods
-      include ComplexExpressionMethods
-      include InequalityMethods
-      include NumericMethods
-      include OrderMethods
-      include StringMethods
-      include SubscriptMethods
-    end
-  end
-end
+#
+# To load the extension:
+#
+#   Sequel.extension :sql_expr
 
 class Object
-  # Return a copy of the object wrapped in a
-  # Sequel::SQL::GenericComplexExpression.  Allows easy use
-  # of the Object with Sequel's DSL.  You'll probably have
-  # to make sure that Sequel knows how to literalize the
-  # object properly, though.
-  def sql_expr
-    Sequel::SQL::GenericComplexExpression.new(:NOOP, self)
-  end
-end
-
-class FalseClass
-  # Returns a copy of the object wrapped in a
-  # Sequel::SQL::BooleanExpression, allowing easy use
-  # of Sequel's DSL:
-  #
-  #   false.sql_expr & :a  # FALSE AND a
-  def sql_expr
-    Sequel::SQL::BooleanExpression.new(:NOOP, self)
-  end
-end
-
-class NilClass
-  # Returns a copy of the object wrapped in a
-  # Sequel::SQL::BooleanExpression, allowing easy use
-  # of Sequel's DSL:
-  #
-  #   ~nil.sql_expr  # NOT NULL
-  def sql_expr
-    Sequel::SQL::BooleanExpression.new(:NOOP, self)
-  end
-end
-
-class Numeric
-  # Returns a copy of the object wrapped in a
-  # Sequel::SQL::NumericExpression, allowing easy use
-  # of Sequel's DSL:
-  #
-  #   1.sql_expr < :a  # 1 < a
-  def sql_expr
-    Sequel::SQL::NumericExpression.new(:NOOP, self)
-  end
-end
-
-class Proc
-  # Evaluates the proc as a virtual row block.
-  # If a hash or array of two element arrays is returned,
-  # they are converted to a Sequel::SQL::BooleanExpression.  Otherwise,
-  # unless the object returned is already an Sequel::SQL::Expression,
-  # convert the object to an Sequel::SQL::GenericComplexExpression.
-  #
-  #   proc{a(b)}.sql_expr + 1  # a(b) + 1
-  #   proc{{a=>b}}.sql_expr | true  # (a = b) OR TRUE
-  #   proc{1}.sql_expr + :a  # 1 + a
+  # Return the object wrapper in an appropriate Sequel expression object.
   def sql_expr
-    o = Sequel.virtual_row(&self)
-    if Sequel.condition_specifier?(o)
-      Sequel::SQL::BooleanExpression.from_value_pairs(o, :AND)
-    elsif o.is_a?(Sequel::SQL::Expression)
-      o
-    else
-      Sequel::SQL::GenericComplexExpression.new(:NOOP, o)
-    end
+    Sequel.expr(self)
   end
 end
-
-class String
-  # Returns a copy of the object wrapped in a
-  # Sequel::SQL::StringExpression, allowing easy use
-  # of Sequel's DSL:
-  #
-  #   "a".sql_expr + :a  # 'a' || a
-  def sql_expr
-    Sequel::SQL::StringExpression.new(:NOOP, self)
-  end
-end
-
-class TrueClass
-  # Returns a copy of the object wrapped in a
-  # Sequel::SQL::BooleanExpression, allowing easy use
-  # of Sequel's DSL:
-  #
-  #   true.sql_expr | :a  # TRUE OR a
-  def sql_expr
-    Sequel::SQL::BooleanExpression.new(:NOOP, self)
-  end
-end
-

data/lib/sequel/extensions/string_date_time.rb

@@ -1,6 +1,10 @@
 # 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.
+#
+# To load the extension:
+#
+#   Sequel.extension :string_date_time
 
 class String
   # Converts a string into a Date object.

data/lib/sequel/extensions/thread_local_timezones.rb

@@ -1,9 +1,15 @@
 # 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,
-# and want to set the timezones based on the request.  The most common example
-# is having the database always store time in UTC, but have the application deal
-# with the timezone of the current user.  That can be done with:
+# and want to set the timezones based on the request.
+#
+# To load the extension:
+#
+#   Sequel.extension :thread_local_timezones
+#
+# The most common example is having the database always store time in
+# UTC, but have the application deal with the timezone of the current
+# user.  That can be done with:
 #
 #   Sequel.database_timezone = :utc
 #   # In each thread:
@@ -32,7 +38,7 @@ module Sequel
   module ThreadLocalTimezones
     %w'application database typecast'.each do |t|
       class_eval("def thread_#{t}_timezone=(tz); Thread.current[:#{t}_timezone] = convert_timezone_setter_arg(tz); end", __FILE__, __LINE__)
-      class_eval(<<END, __FILE__, __LINE__)
+      class_eval(<<END, __FILE__, __LINE__ + 1)
         def #{t}_timezone
           if tz = Thread.current[:#{t}_timezone]
             tz unless tz == :nil

data/lib/sequel/extensions/to_dot.rb

@@ -2,111 +2,117 @@
 # 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
 # of the dataset's abstract syntax tree.
+#
+# To load the extension:
+#
+#   Sequel.extension :to_dot
 
 module Sequel
-  class Dataset
+  class ToDot
     # The option keys that should be included in the dot output.
     TO_DOT_OPTIONS = [:with, :distinct, :select, :from, :join, :where, :group, :having, :compounds, :order, :limit, :offset, :lock].freeze
 
-    # Return a string that can be processed by the +dot+ program (included
-    # with graphviz) in order to see a visualization of the dataset's
-    # abstract syntax tree.
-    def to_dot
-      i = 0
-      dot = ["digraph G {", "#{i} [label=\"self\"];"]
-      _to_dot(dot, "", i, self, i)
-      dot << "}"
-      dot.join("\n")
+    # Given a +Dataset+, return a string in +dot+ format that will
+    # generate a visualization of the dataset.
+    def self.output(ds)
+      new(ds).output
+    end
+
+    # Given a +Dataset+, parse the internal structure to generate
+    # a dataset visualization.
+    def initialize(ds)
+      @i = 0
+      @stack = [@i]
+      @dot = ["digraph G {", "0 [label=\"self\"];"]
+      v(ds, "")
+      @dot << "}"
+    end
+
+    # Output the dataset visualization as a string in +dot+ format.
+    def output
+      @dot.join("\n")
     end
 
     private
 
-    # Internal recursive version that handles all object types understood
-    # by Sequel.  Arguments:
-    # * dot :: An array of strings representing the lines in the returned
-    #          output.  This function just pushes strings onto this array.
-    # * l :: The transition label from the parent node of the AST to the
-    #        current node.
-    # * c :: An integer representing the parent node of the AST.
-    # * e :: The current node of the AST.
-    # * i :: The integer representing the last created node of the AST.
-    #
-    # The basic algorithm is that the +i+ is incremented to get the current
-    # node's integer.  Then the transition from the parent node to the
-    # current node is added to the +dot+ array.  Finally, the current node
-    # is added to the +dot+ array, and if it is a compound node with children,
-    # its children are then added by recursively calling this method. The
-    # return value is the integer representing the last created node.
-    def _to_dot(dot, l, c, e, i)
-      i += 1
-      dot << "#{c} -> #{i} [label=\"#{l}\"];" if l
-      c = i
+    # Add an entry to the +dot+ output with the given label.  If +j+
+    # 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}];"
+    end
+
+    # Recursive method that parses all of Sequel's internal datastructures,
+    # adding the appropriate nodes and transitions to the internal +dot+
+    # structure.
+    def v(e, l)
+      @i += 1
+      dot(l, "#{@stack.last} -> #{@i}") if l
+      @stack.push(@i)
       case e
       when LiteralString
-        dot << "#{i} [label=\"#{e.inspect.gsub('"', '\\"')}.lit\"];"
-        i
+        dot "#{e.inspect}.lit" # core_sql use
       when Symbol, Numeric, String, Class, TrueClass, FalseClass, NilClass
-        dot << "#{i} [label=\"#{e.inspect.gsub('"', '\\"')}\"];"
-        i
+        dot e.inspect
       when Array
-        dot << "#{i} [label=\"Array\"];"
-        e.each_with_index do |v, j|
-          i = _to_dot(dot, j, c, v, i)
+        dot "Array"
+        e.each_with_index do |val, j|
+          v(val, j)
         end
       when Hash
-        dot << "#{i} [label=\"Hash\"];"
-        e.each do |k, v|
-          i = _to_dot(dot, k, c, v, i)
+        dot "Hash"
+        e.each do |k, val|
+          v(val, k)
         end
       when SQL::ComplexExpression 
-        dot << "#{i} [label=\"ComplexExpression: #{e.op}\"];"
-        e.args.each_with_index do |v, j|
-          i = _to_dot(dot, j, c, v, i)
+        dot "ComplexExpression: #{e.op}"
+        e.args.each_with_index do |val, j|
+          v(val, j)
         end
       when SQL::Identifier
-        dot << "#{i} [label=\"Identifier\"];"
-        i = _to_dot(dot, :value, c, e.value, i)
+        dot "Identifier"
+        v(e.value, :value)
       when SQL::QualifiedIdentifier
-        dot << "#{i} [label=\"QualifiedIdentifier\"];"
-        i = _to_dot(dot, :table, c, e.table, i)
-        i = _to_dot(dot, :column, c, e.column, i)
+        dot "QualifiedIdentifier"
+        v(e.table, :table)
+        v(e.column, :column)
       when SQL::OrderedExpression
-        dot << "#{i} [label=\"OrderedExpression: #{e.descending ? :DESC : :ASC}#{" NULLS #{e.nulls.to_s.upcase}" if e.nulls}\"];"
-        i = _to_dot(dot, :expression, c, e.expression, i)
+        dot "OrderedExpression: #{e.descending ? :DESC : :ASC}#{" NULLS #{e.nulls.to_s.upcase}" if e.nulls}"
+        v(e.expression, :expression)
       when SQL::AliasedExpression
-        dot << "#{i} [label=\"AliasedExpression\"];"
-        i = _to_dot(dot, :expression, c, e.expression, i)
-        i = _to_dot(dot, :alias, c, e.aliaz, i)
+        dot "AliasedExpression"
+        v(e.expression, :expression)
+        v(e.aliaz, :alias)
       when SQL::CaseExpression
-        dot << "#{i} [label=\"CaseExpression\"];"
-        i = _to_dot(dot, :expression, c, e.expression, i) if e.expression
-        i = _to_dot(dot, :conditions, c, e.conditions, i)
-        i = _to_dot(dot, :default, c, e.default, i)
+        dot "CaseExpression"
+        v(e.expression, :expression) if e.expression
+        v(e.conditions, :conditions)
+        v(e.default, :default)
       when SQL::Cast
-        dot << "#{i} [label=\"Cast\"];"
-        i = _to_dot(dot, :expr, c, e.expr, i)
-        i = _to_dot(dot, :type, c, e.type, i)
+        dot "Cast"
+        v(e.expr, :expr)
+        v(e.type, :type)
       when SQL::Function
-        dot << "#{i} [label=\"Function: #{e.f}\"];"
-        e.args.each_with_index do |v, j|
-          i = _to_dot(dot, j, c, v, i)
+        dot "Function: #{e.f}"
+        e.args.each_with_index do |val, j|
+          v(val, j)
         end
       when SQL::Subscript 
-        dot << "#{i} [label=\"Subscript: #{e.f}\"];"
-        i = _to_dot(dot, :f, c, e.f, i)
-        i = _to_dot(dot, :sub, c, e.sub, i)
+        dot "Subscript"
+        v(e.f, :f)
+        v(e.sub, :sub)
       when SQL::WindowFunction
-        dot << "#{i} [label=\"WindowFunction\"];"
-        i = _to_dot(dot, :function, c, e.function, i)
-        i = _to_dot(dot, :window, c, e.window, i)
+        dot "WindowFunction"
+        v(e.function, :function)
+        v(e.window, :window)
       when SQL::Window
-        dot << "#{i} [label=\"Window\"];"
-        i = _to_dot(dot, :opts, c, e.opts, i)
+        dot "Window"
+        v(e.opts, :opts)
       when SQL::PlaceholderLiteralString
         str = e.str
         str = "(#{str})" if e.parens
-        dot << "#{i} [label=\"PlaceholderLiteralString: #{str.inspect.gsub('"', '\\"')}\"];"
-        i = _to_dot(dot, :args, c, e.args, i)
+        dot "PlaceholderLiteralString: #{str.inspect}"
+        v(e.args, :args)
       when SQL::JoinClause
         str = "#{e.join_type.to_s.upcase} JOIN"
         if e.is_a?(SQL::JoinOnClause)
@@ -114,24 +120,34 @@ module Sequel
         elsif e.is_a?(SQL::JoinUsingClause)
           str << " USING"
         end
-        dot << "#{i} [label=\"#{str}\"];"
-        i = _to_dot(dot, :table, c, e.table, i)
-        i = _to_dot(dot, :alias, c, e.table_alias, i) if e.table_alias
+        dot str
+        v(e.table, :table)
+        v(e.table_alias, :alias) if e.table_alias
         if e.is_a?(SQL::JoinOnClause)
-          i = _to_dot(dot, :on, c, e.on, i)
+          v(e.on, :on) 
         elsif e.is_a?(SQL::JoinUsingClause)
-          i = _to_dot(dot, :using, c, e.using, i)
+          v(e.using, :using) 
         end
       when Dataset
-        dot << "#{i} [label=\"Dataset\"];"
+        dot "Dataset"
         TO_DOT_OPTIONS.each do |k|
-          next unless e.opts[k]
-          i = _to_dot(dot, k, c, e.opts[k], i)
+          if val = e.opts[k]
+            v(val, k.to_s) 
+          end
         end
       else
-        dot << "#{i} [label=\"Unhandled: #{e.inspect.gsub('"', "''")}\"];"
+        dot "Unhandled: #{e.inspect}"
       end
-      i
+      @stack.pop
+    end
+  end
+
+  class Dataset
+    # Return a string that can be processed by the +dot+ program (included
+    # with graphviz) in order to see a visualization of the dataset's
+    # abstract syntax tree.
+    def to_dot
+      ToDot.output(self)
     end
   end
 end