sequel 3.8.0 → 3.9.0

data/lib/sequel/core.rb

@@ -17,18 +17,6 @@
 #
 #   Sequel.sqlite('blog.db'){|db| puts db[:users].count} 
 #
-# Sequel converts two digit years in Dates and DateTimes by default,
-# so 01/02/03 is interpreted at January 2nd, 2003, and 12/13/99 is interpreted
-# as December 13, 1999. You can override this to treat those dates as
-# January 2nd, 0003 and December 13, 0099, respectively, by setting: 
-#
-#   Sequel.convert_two_digit_years = false
-#
-# Sequel can use either Time or DateTime for times returned from the
-# database.  It defaults to Time.  To change it to DateTime, use:
-#
-#   Sequel.datetime_class = DateTime
-#
 # Sequel doesn't pay much attention to timezones by default, but you can set it
 # handle timezones if you want.  There are three separate timezone settings:
 #
@@ -62,9 +50,42 @@ module Sequel
   @convert_two_digit_years = true
   @datetime_class = Time
   @virtual_row_instance_eval = true
+  @require_thread = nil
+  
+  # Mutex used to protect file loading
+  @require_mutex = Mutex.new
   
   class << self
-    attr_accessor :convert_two_digit_years, :datetime_class, :virtual_row_instance_eval
+    # Sequel converts two digit years in Dates and DateTimes by default,
+    # so 01/02/03 is interpreted at January 2nd, 2003, and 12/13/99 is interpreted
+    # as December 13, 1999. You can override this to treat those dates as
+    # January 2nd, 0003 and December 13, 0099, respectively, by setting this to false.
+    attr_accessor :convert_two_digit_years
+
+    # Sequel can use either Time or DateTime for times returned from the
+    # database.  It defaults to Time.  To change it to DateTime, set this to DateTime.
+    attr_accessor :datetime_class
+
+    attr_accessor :virtual_row_instance_eval
+    
+    # Alias to the standard version of require
+    alias k_require require
+
+    private
+
+    # Make thread safe requiring reentrant to prevent deadlocks.
+    def check_requiring_thread
+      t = Thread.current
+      return(yield) if @require_thread == t
+      @require_mutex.synchronize do
+        begin
+          @require_thread = t 
+          yield
+        ensure
+          @require_thread = nil
+        end
+      end
+    end
   end
 
   # Returns true if the passed object could be a specifier of conditions, false otherwise.
@@ -117,7 +138,7 @@ module Sequel
   #   Sequel.extension(:schema_dumper)
   #   Sequel.extension(:pagination, :query)
   def self.extension(*extensions)
-    require(extensions, 'extensions')
+    extensions.each{|e| tsk_require "sequel/extensions/#{e}"}
   end
   
   # Set the method to call on identifiers going into the database.  This affects
@@ -158,7 +179,7 @@ module Sequel
   def self.quote_identifiers=(value)
     Database.quote_identifiers = value
   end
-
+  
   # Require all given files which should be in the same or a subdirectory of
   # this file.  If a subdir is given, assume all files are in that subdir.
   def self.require(files, subdir=nil)
@@ -207,6 +228,16 @@ module Sequel
     end
   end
 
+  # Same as Sequel.require, but wrapped in a mutex in order to be thread safe.
+  def self.ts_require(*args)
+    check_requiring_thread{require(*args)}
+  end
+  
+  # Same as Kernel.require, but wrapped in a mutex in order to be thread safe.
+  def self.tsk_require(*args)
+    check_requiring_thread{k_require(*args)}
+  end
+
   # If the supplied block takes a single argument,
   # yield a new SQL::VirtualRow instance to the block
   # argument.  Otherwise, evaluate the block in the context of a new

data/lib/sequel/database.rb

@@ -80,20 +80,22 @@ module Sequel
     # is given, it is used as the connection_proc for the ConnectionPool.
     def initialize(opts = {}, &block)
       @opts ||= opts
+      @opts = connection_pool_default_options.merge(@opts)
+      @loggers = Array(@opts[:logger]) + Array(@opts[:loggers])
+      @opts[:disconnection_proc] ||= proc{|conn| disconnect_connection(conn)}
+      block ||= proc{|server| connect(server)}
+      @opts[:servers] = {} if @opts[:servers].is_a?(String)
       
-      @single_threaded = opts.include?(:single_threaded) ? typecast_value_boolean(opts[:single_threaded]) : @@single_threaded
+      @opts[:single_threaded] = @single_threaded = @opts.include?(:single_threaded) ? typecast_value_boolean(@opts[:single_threaded]) : @@single_threaded
       @schemas = {}
-      @default_schema = opts.include?(:default_schema) ? opts[:default_schema] : default_schema_default
+      @default_schema = opts.include?(:default_schema) ? @opts[:default_schema] : default_schema_default
       @prepared_statements = {}
       @transactions = []
       @identifier_input_method = nil
       @identifier_output_method = nil
       @quote_identifiers = nil
-      @pool = (@single_threaded ? SingleThreadedPool : ConnectionPool).new(connection_pool_default_options.merge(opts), &block)
-      @pool.connection_proc = proc{|server| connect(server)} unless block
-      @pool.disconnection_proc = proc{|conn| disconnect_connection(conn)} unless opts[:disconnection_proc]
+      @pool = ConnectionPool.get_pool(@opts, &block)
 
-      @loggers = Array(opts[:logger]) + Array(opts[:loggers])
       ::Sequel::DATABASES.push(self)
     end
     
@@ -108,7 +110,7 @@ module Sequel
       unless klass = ADAPTER_MAP[scheme]
         # attempt to load the adapter file
         begin
-          Sequel.require "adapters/#{scheme}"
+          Sequel.tsk_require "sequel/adapters/#{scheme}"
         rescue LoadError => e
           raise Sequel.convert_exception_class(e, AdapterNotFound)
         end
@@ -139,7 +141,7 @@ module Sequel
           scheme = :dbi if scheme =~ /\Adbi-/
           c = adapter_class(scheme)
           uri_options = c.send(:uri_to_options, uri)
-          uri.query.split('&').collect{|s| s.split('=')}.each{|k,v| uri_options[k.to_sym] = v} unless uri.query.to_s.strip.empty?
+          uri.query.split('&').collect{|s| s.split('=')}.each{|k,v| uri_options[k.to_sym] = v if k && !k.empty?} unless uri.query.to_s.strip.empty?
           uri_options.entries.each{|k,v| uri_options[k] = URI.unescape(v) if v.is_a?(String)}
           opts = uri_options.merge(opts)
         end
@@ -281,7 +283,7 @@ module Sequel
     end
 
     # Connects to the database. This method should be overridden by descendants.
-    def connect
+    def connect(server)
       raise NotImplementedError, "#connect should be overridden by adapters"
     end
     

data/lib/sequel/dataset/convenience.rb

@@ -274,6 +274,29 @@ module Sequel
       end
     end
 
+    # Creates a unique table alias that hasn't already been used in the dataset.
+    # table_alias can be any type of object accepted by alias_symbol.
+    # The symbol returned will be the implicit alias in the argument,
+    # possibly appended with "_N" if the implicit alias has already been
+    # used, where N is an integer starting at 0 and increasing until an
+    # unused one is found.
+    def unused_table_alias(table_alias)
+      table_alias = alias_symbol(table_alias)
+      used_aliases = []
+      used_aliases += opts[:from].map{|t| alias_symbol(t)} if opts[:from]
+      used_aliases += opts[:join].map{|j| j.table_alias ? alias_alias_symbol(j.table_alias) : alias_symbol(j.table)} if opts[:join]
+      if used_aliases.include?(table_alias)
+        i = 0
+        loop do
+          ta = :"#{table_alias}_#{i}"
+          return ta unless used_aliases.include?(ta)
+          i += 1 
+        end
+      else
+        table_alias
+      end
+    end
+
     private
 
     # Return a plain symbol given a potentially qualified or aliased symbol,

data/lib/sequel/dataset/graph.rb

@@ -5,7 +5,7 @@ module Sequel
     # #set_graph_aliases.
     def add_graph_aliases(graph_aliases)
       ds = select_more(*graph_alias_columns(graph_aliases))
-      ds.opts[:graph_aliases] = (ds.opts[:graph_aliases] || ds.opts[:graph][:column_aliases] || {}).merge(graph_aliases)
+      ds.opts[:graph_aliases] = (ds.opts[:graph_aliases] || (ds.opts[:graph][:column_aliases] rescue {}) || {}).merge(graph_aliases)
       ds
     end
 
@@ -102,7 +102,7 @@ module Sequel
 
       # Setup the initial graph data structure if it doesn't exist
       unless graph = opts[:graph]
-        master = ds.first_source_alias
+        master = alias_symbol(ds.first_source_alias)
         raise_alias_error.call if master == table_alias
         # Master hash storing all .graph related information
         graph = opts[:graph] = {}

data/lib/sequel/dataset/query.rb

@@ -221,12 +221,16 @@ module Sequel
         o = l.first
         l = l.last - l.first + (l.exclude_end? ? 0 : 1)
       end
-      l = l.to_i
-      raise(Error, 'Limits must be greater than or equal to 1') unless l >= 1
+      l = l.to_i if l.is_a?(String) && !l.is_a?(LiteralString)
+      if l.is_a?(Integer)
+        raise(Error, 'Limits must be greater than or equal to 1') unless l >= 1
+      end
       opts = {:limit => l}
       if o
-        o = o.to_i
-        raise(Error, 'Offsets must be greater than or equal to 0') unless o >= 0
+        o = o.to_i if o.is_a?(String) && !o.is_a?(LiteralString)
+        if o.is_a?(Integer)
+          raise(Error, 'Offsets must be greater than or equal to 0') unless o >= 0
+        end
         opts[:offset] = o
       end
       clone(opts)
@@ -285,7 +289,7 @@ module Sequel
     #
     #   dataset.select(:a) # SELECT a FROM items
     #   dataset.select(:a, :b) # SELECT a, b FROM items
-    #   dataset.select{|o| o.a, o.sum(:b)} # SELECT a, sum(b) FROM items
+    #   dataset.select{|o| [o.a, o.sum(:b)]} # SELECT a, sum(b) FROM items
     def select(*columns, &block)
       columns += Array(Sequel.virtual_row(&block)) if block
       m = []

data/lib/sequel/dataset/sql.rb

@@ -91,11 +91,42 @@ module Sequel
         end
       when :IN, :"NOT IN"
         cols = args.at(0)
-        if !supports_multiple_column_in? && cols.is_a?(Array)
-          expr = SQL::BooleanExpression.new(:OR, *args.at(1).to_a.map{|vals| SQL::BooleanExpression.from_value_pairs(cols.zip(vals).map{|col, val| [col, val]})})
-          literal(op == :IN ? expr : ~expr)
+        vals = args.at(1)
+        col_array = true if cols.is_a?(Array) || cols.is_a?(SQL::SQLArray)
+        if vals.is_a?(Array) || vals.is_a?(SQL::SQLArray)
+          val_array = true
+          empty_val_array = vals.to_a == []
+        end
+        if col_array
+          if empty_val_array
+            if op == :IN
+              literal(SQL::BooleanExpression.from_value_pairs(cols.to_a.map{|x| [x, x]}, :AND, true))
+            else
+              literal(1=>1)
+            end
+          elsif !supports_multiple_column_in?
+            if val_array
+              expr = SQL::BooleanExpression.new(:OR, *vals.to_a.map{|vs| SQL::BooleanExpression.from_value_pairs(cols.to_a.zip(vs).map{|c, v| [c, v]})})
+              literal(op == :IN ? expr : ~expr)
+            else
+              old_vals = vals
+              vals = vals.to_a
+              val_cols = old_vals.columns
+              complex_expression_sql(op, [cols, vals.map!{|x| x.values_at(*val_cols)}])
+            end
+          else
+            "(#{literal(cols)} #{op} #{literal(vals)})"
+          end
         else
-          "(#{literal(cols)} #{op} #{literal(args.at(1))})"
+          if empty_val_array
+            if op == :IN
+              literal(SQL::BooleanExpression.from_value_pairs([[cols, cols]], :AND, true))
+            else
+              literal(1=>1)
+            end
+          else
+            "(#{literal(cols)} #{op} #{literal(vals)})"
+          end
         end
       when *TWO_ARITY_OPERATORS
         "(#{literal(args.at(0))} #{op} #{literal(args.at(1))})"
@@ -288,13 +319,17 @@ module Sequel
         return join_table(type, table, h, options)
       end
 
-      if [Symbol, String].any?{|c| options.is_a?(c)}
+      case options
+      when Hash
+        table_alias = options[:table_alias]
+        last_alias = options[:implicit_qualifier]
+      when Symbol, String, SQL::Identifier
         table_alias = options
         last_alias = nil 
       else
-        table_alias = options[:table_alias]
-        last_alias = options[:implicit_qualifier]
+        raise Error, "invalid options format for join_table: #{options.inspect}"
       end
+
       if Dataset === table
         if table_alias.nil?
           table_alias_num = (@opts[:num_dataset_sources] || 0) + 1
@@ -360,7 +395,7 @@ module Sequel
       when BigDecimal
         literal_big_decimal(v)
       when NilClass
-        NULL
+        literal_nil
       when TrueClass
         literal_true
       when FalseClass
@@ -630,6 +665,41 @@ module Sequel
       "TRUNCATE TABLE #{table}"
     end
 
+    # Returns an appropriate symbol for the alias represented by s.
+    def alias_alias_symbol(s)
+      case s
+      when Symbol
+        s
+      when String
+        s.to_sym
+      when SQL::Identifier
+        s.value.to_s.to_sym
+      else
+        raise Error, "Invalid alias for alias_alias_symbol: #{s.inspect}"
+      end
+    end
+
+    # Returns an appropriate alias symbol for the given object, which can be
+    # a Symbol, String, SQL::Identifier, SQL::QualifiedIdentifier, or
+    # SQL::AliasedExpression.
+    def alias_symbol(sym)
+      case sym
+      when Symbol
+        s, t, a = split_symbol(sym)
+        a || s ? (a || t).to_sym : sym
+      when String
+        sym.to_sym
+      when SQL::Identifier
+        sym.value.to_s.to_sym
+      when SQL::QualifiedIdentifier
+        alias_symbol(sym.column)
+      when SQL::AliasedExpression
+        alias_alias_symbol(sym.aliaz)
+      else
+        raise Error, "Invalid alias for alias_symbol: #{sym.inspect}"
+      end
+    end
+
     # Clone of this dataset usable in aggregate operations.  Does
     # a from_self if dataset contains any parameters that would
     # affect normal aggregation, or just removes an existing
@@ -791,7 +861,7 @@ module Sequel
 
     # SQL fragment for Date, using the ISO8601 format.
     def literal_date(v)
-      requires_sql_standard_datetimes? ? v.strftime("DATE '%Y-%m-%d'") : "'#{v}'"
+      v.strftime("#{'DATE ' if requires_sql_standard_datetimes?}'%Y-%m-%d'")
     end
 
     # SQL fragment for DateTime
@@ -823,6 +893,11 @@ module Sequel
     def literal_integer(v)
       v.to_s
     end
+    
+    # SQL fragment for nil
+    def literal_nil
+      NULL
+    end
 
     # SQL fragment for a type of object not handled by Dataset#literal.
     # Calls sql_literal if object responds to it, otherwise raises an error.
@@ -996,8 +1071,8 @@ module Sequel
 
     # Modify the sql to limit the number of rows returned and offset
     def select_limit_sql(sql)
-      sql << " LIMIT #{@opts[:limit]}" if @opts[:limit]
-      sql << " OFFSET #{@opts[:offset]}" if @opts[:offset]
+      sql << " LIMIT #{literal(@opts[:limit])}" if @opts[:limit]
+      sql << " OFFSET #{literal(@opts[:offset])}" if @opts[:offset]
     end
 
     # Modify the sql to add the expressions to ORDER BY
@@ -1087,7 +1162,7 @@ module Sequel
         values = values.merge(opts[:overrides]) if opts[:overrides]
         # get values from hash
         values.map do |k, v|
-          "#{[String, Symbol].any?{|c| k.is_a?(c)} ? quote_identifier(k) : literal(k)} = #{literal(v)}"
+          "#{k.is_a?(String) && !k.is_a?(LiteralString) ? quote_identifier(k) : literal(k)} = #{literal(v)}"
         end.join(COMMA_SEPARATOR)
       else
         # copy values verbatim

data/lib/sequel/extensions/inflector.rb

@@ -23,7 +23,14 @@ class String
     @plurals, @singulars, @uncountables = [], [], []
 
     class << self
-      attr_reader :plurals, :singulars, :uncountables
+      # Array of 2 element arrays, first containing a regex, and the second containing a substitution pattern, used for plurization.
+      attr_reader :plurals
+
+      # Array of 2 element arrays, first containing a regex, and the second containing a substitution pattern, used for singularization.
+      attr_reader :singulars
+
+      # Array of strings for words were the singular form is the same as the plural form
+      attr_reader :uncountables
     end
 
     # Clears the loaded inflections within a given scope (default is :all). Give the scope as a symbol of the inflection type,

data/lib/sequel/extensions/schema_dumper.rb

@@ -11,7 +11,7 @@ module Sequel
     # * :same_db - Create a dump for the same database type, so
     #   don't ignore errors if the index statements fail.
     def dump_indexes_migration(options={})
-      ts = tables
+      ts = tables(options)
       <<END_MIG
 Class.new(Sequel::Migration) do
   def up
@@ -35,7 +35,7 @@ END_MIG
     # * :indexes - If set to false, don't dump indexes (they can be added
     #   later via dump_index_migration).
     def dump_schema_migration(options={})
-      ts = tables
+      ts = tables(options)
       <<END_MIG
 Class.new(Sequel::Migration) do
   def up
@@ -135,8 +135,7 @@ END_MIG
       when /\An?char(?:acter)?(?:\((\d+)\))?\z/o
         {:type=>String, :size=>($1.to_i if $1), :fixed=>true}
       when /\A(?:n?varchar|character varying|bpchar|string)(?:\((\d+)\))?\z/o
-        s = ($1.to_i if $1)
-        {:type=>String, :size=>(s == 255 ? nil : s)}
+        {:type=>String, :size=>($1.to_i if $1)}
       when /\A(?:small)?money\z/o
         {:type=>BigDecimal, :size=>[19,2]}
       when /\A(?:decimal|numeric|number)(?:\((\d+)(?:,\s*(\d+))?\))?\z/o

data/lib/sequel/model/associations.rb

@@ -763,7 +763,7 @@ module Sequel
           jt_join_type = opts[:graph_join_table_join_type]
           jt_graph_block = opts[:graph_join_table_block]
           opts[:eager_grapher] ||= proc do |ds, assoc_alias, table_alias|
-            ds = ds.graph(join_table, use_jt_only_conditions ? jt_only_conditions : lcks.zip(lcpks) + graph_jt_conds, :select=>false, :table_alias=>ds.send(:eager_unique_table_alias, ds, join_table), :join_type=>jt_join_type, :implicit_qualifier=>table_alias, :from_self_alias=>ds.opts[:eager_graph][:master], &jt_graph_block)
+            ds = ds.graph(join_table, use_jt_only_conditions ? jt_only_conditions : lcks.zip(lcpks) + graph_jt_conds, :select=>false, :table_alias=>ds.unused_table_alias(join_table), :join_type=>jt_join_type, :implicit_qualifier=>table_alias, :from_self_alias=>ds.opts[:eager_graph][:master], &jt_graph_block)
             ds.graph(opts.associated_class, use_only_conditions ? only_conditions : opts.right_primary_keys.zip(rcks) + conditions, :select=>select, :table_alias=>assoc_alias, :join_type=>join_type, &graph_block)
           end
       
@@ -1213,8 +1213,6 @@ module Sequel
         # Like eager, you need to call .all on the dataset for the eager loading to work.  If you just
         # call each, you will get a normal graphed result back (a hash with model object values).
         def eager_graph(*associations)
-          table_name = model.table_name
-            
           ds = if @opts[:eager_graph]
             self
           else
@@ -1223,9 +1221,9 @@ module Sequel
             # :requirements - array of requirements for this association
             # :alias_association_type_map - the type of association for this association
             # :alias_association_name_map - the name of the association for this association
-            clone(:eager_graph=>{:requirements=>{}, :master=>table_name, :alias_association_type_map=>{}, :alias_association_name_map=>{}, :reciprocals=>{}, :cartesian_product_number=>0})
+            clone(:eager_graph=>{:requirements=>{}, :master=>alias_symbol(first_source), :alias_association_type_map=>{}, :alias_association_name_map=>{}, :reciprocals=>{}, :cartesian_product_number=>0})
           end
-          ds.eager_graph_associations(ds, model, table_name, [], *associations)
+          ds.eager_graph_associations(ds, model, ds.opts[:eager_graph][:master], [], *associations)
         end
         
         # Do not attempt to split the result set into associations,
@@ -1253,9 +1251,9 @@ module Sequel
         def eager_graph_association(ds, model, ta, requirements, r, *associations)
           klass = r.associated_class
           assoc_name = r[:name]
-          assoc_table_alias = ds.eager_unique_table_alias(ds, assoc_name)
+          assoc_table_alias = ds.unused_table_alias(assoc_name)
           ds = r[:eager_grapher].call(ds, assoc_table_alias, ta)
-          ds = ds.order_more(*Array(r[:order]).map{|c| eager_graph_qualify_order(assoc_table_alias, c)}) if r[:order] and r[:order_eager_graph]
+          ds = ds.order_more(*qualified_expression(r[:order], assoc_table_alias)) if r[:order] and r[:order_eager_graph]
           eager_graph = ds.opts[:eager_graph]
           eager_graph[:requirements][assoc_table_alias] = requirements.dup
           eager_graph[:alias_association_name_map][assoc_table_alias] = assoc_name
@@ -1354,25 +1352,6 @@ module Sequel
           record_graphs.replace(records)
         end
       
-        # Creates a unique table alias that hasn't already been used in the query.
-        # Will either be the table_alias itself or table_alias_N for some integer
-        # N (starting at 0 and increasing until an unused one is found).
-        def eager_unique_table_alias(ds, table_alias)
-          used_aliases = ds.opts[:from]
-          used_aliases += ds.opts[:join].map{|j| j.table_alias || j.table} if ds.opts[:join]
-          graph = ds.opts[:graph]
-          used_aliases += graph[:table_aliases].keys if graph
-          if used_aliases.include?(table_alias)
-            i = 0
-            loop do
-              ta = :"#{table_alias}_#{i}"
-              return ta unless used_aliases.include?(ta)
-              i += 1
-            end
-          end
-          table_alias
-        end
-
         private
       
         # Make sure the association is valid for this model, and return the related AssociationReflection.
@@ -1433,23 +1412,6 @@ module Sequel
           end
         end
       
-        # Qualify the given expression if necessary.  The only expressions which are qualified are
-        # unqualified symbols and identifiers, either of which may by sorted.
-        def eager_graph_qualify_order(table_alias, expression)
-          case expression
-          when Symbol
-            table, column, aliaz = split_symbol(expression)
-            raise(Sequel::Error, "Can't use an aliased expression in the :order option") if aliaz
-            table ? expression : Sequel::SQL::QualifiedIdentifier.new(table_alias, expression)
-          when Sequel::SQL::Identifier
-            Sequel::SQL::QualifiedIdentifier.new(table_alias, expression)
-          when Sequel::SQL::OrderedExpression
-            Sequel::SQL::OrderedExpression.new(eager_graph_qualify_order(table_alias, expression.expression), expression.descending)
-          else
-            expression
-          end
-        end
-      
         # Eagerly load all specified associations 
         def eager_load(a, eager_assoc=@opts[:eager])
           return if a.empty?