sequel 3.21.0 → 3.32.0

data/lib/sequel/adapters/tinytds.rb

@@ -11,16 +11,11 @@ module Sequel
       # :dataserver and :username options.
       def connect(server)
         opts = server_opts(server)
-        opts[:dataserver] = opts[:host]
         opts[:username] = opts[:user]
+        set_mssql_unicode_strings
         TinyTds::Client.new(opts)
       end
       
-      # Return instance of Sequel::TinyTDS::Dataset with the given options.
-      def dataset(opts = nil)
-        TinyTDS::Dataset.new(self, opts)
-      end
-    
       # Execute the given +sql+ on the server.  If the :return option
       # is present, its value should be a method symbol that is called
       # on the TinyTds::Result object returned from executing the
@@ -32,13 +27,36 @@ module Sequel
           begin
             m = opts[:return]
             r = nil
-            log_yield(sql) do
-              r = c.execute(sql)
-              return r.send(m) if m
+            if (args = opts[:arguments]) && !args.empty?
+              types = []
+              values = []
+              args.each_with_index do |(k, v), i|
+                v, type = ps_arg_type(v)
+                types << "@#{k} #{type}"
+                values << "@#{k} = #{v}"
+              end
+              case m
+              when :do
+                sql = "#{sql}; SELECT @@ROWCOUNT AS AffectedRows"
+                single_value = true
+              when :insert
+                sql = "#{sql}; SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident"
+                single_value = true
+              end
+              sql = "EXEC sp_executesql N'#{c.escape(sql)}', N'#{c.escape(types.join(', '))}', #{values.join(', ')}"
+              log_yield(sql) do
+                r = c.execute(sql)
+                r.each{|row| return row.values.first} if single_value
+              end
+            else
+              log_yield(sql) do
+                r = c.execute(sql)
+                return r.send(m) if m
+              end
             end
             yield(r) if block_given?
           rescue TinyTds::Error => e
-            raise_error(e)
+            raise_error(e, :disconnect=>!c.active?)
           ensure
            r.cancel if r && c.sqlsent?
           end
@@ -74,51 +92,174 @@ module Sequel
         super
       end
 
+      # tiny_tds uses TinyTds::Error as the base error class.
+      def database_error_classes
+        [TinyTds::Error]
+      end
+
       # Close the TinyTds::Client object.
       def disconnect_connection(c)
         c.close
       end
+
+      # Return true if the :conn argument is present and not active.
+      def disconnect_error?(e, opts)
+        super || (opts[:conn] && !opts[:conn].active?)
+      end
+
+      # Return a 2 element array with the literal value and type to use
+      # in the prepared statement call for the given value and connection.
+      def ps_arg_type(v)
+        case v
+        when Fixnum
+          [v, 'int']
+        when Bignum
+          [v, 'bigint']
+        when Float
+          [v, 'double precision']
+        when Numeric
+          [v, 'numeric']
+        when Time
+          if v.is_a?(SQLTime)
+            [literal(v), 'time']
+          else
+            [literal(v), 'datetime']
+          end
+        when DateTime
+          [literal(v), 'datetime']
+        when Date
+          [literal(v), 'date']
+        when nil
+          ['NULL', 'nvarchar(max)']
+        when true
+          ['1', 'int']
+        when false
+          ['0', 'int']
+        when SQL::Blob
+          [literal(v), 'varbinary(max)']
+        else
+          [literal(v), 'nvarchar(max)']
+        end
+      end
     end
     
     class Dataset < Sequel::Dataset
       include Sequel::MSSQL::DatasetMethods
+
+      Database::DatasetClass = self
+      
+      # SQLite already supports named bind arguments, so use directly.
+      module ArgumentMapper
+        include Sequel::Dataset::ArgumentMapper
+        
+        protected
+        
+        # Return a hash with the same values as the given hash,
+        # but with the keys converted to strings.
+        def map_to_prepared_args(hash)
+          args = {}
+          hash.each{|k,v| args[k.to_s.gsub('.', '__')] = v}
+          args
+        end
+        
+        private
+        
+        # SQLite uses a : before the name of the argument for named
+        # arguments.
+        def prepared_arg(k)
+          LiteralString.new("@#{k.to_s.gsub('.', '__')}")
+        end
+
+        # Always assume a prepared argument.
+        def prepared_arg?(k)
+          true
+        end
+      end
+      
+      # SQLite prepared statement uses a new prepared statement each time
+      # it is called, but it does use the bind arguments.
+      module PreparedStatementMethods
+        include ArgumentMapper
+        
+        private
+        
+        # Run execute_select on the database with the given SQL and the stored
+        # bind arguments.
+        def execute(sql, opts={}, &block)
+          super(prepared_sql, {:arguments=>bind_arguments}.merge(opts), &block)
+        end
+        
+        # Same as execute, explicit due to intricacies of alias and super.
+        def execute_dui(sql, opts={}, &block)
+          super(prepared_sql, {:arguments=>bind_arguments}.merge(opts), &block)
+        end
+        
+        # Same as execute, explicit due to intricacies of alias and super.
+        def execute_insert(sql, opts={}, &block)
+          super(prepared_sql, {:arguments=>bind_arguments}.merge(opts), &block)
+        end
+      end
       
       # Yield hashes with symbol keys, attempting to optimize for
       # various cases.
       def fetch_rows(sql)
         execute(sql) do |result|
           each_opts = {:cache_rows=>false}
-          each_opts[:timezone] = :utc if Sequel.database_timezone == :utc
-          offset = @opts[:offset]
-          @columns = cols = result.fields.map{|c| output_identifier(c)}
-          if identifier_output_method
+          each_opts[:timezone] = :utc if db.timezone == :utc
+          rn = row_number_column if offset = @opts[:offset]
+          columns = cols = result.fields.map{|c| output_identifier(c)}
+          if offset
+            rn = row_number_column
+            columns = columns.dup
+            columns.delete(rn)
+          end
+          @columns = columns
+          #if identifier_output_method
             each_opts[:as] = :array
             result.each(each_opts) do |r|
               h = {}
               cols.zip(r).each{|k, v| h[k] = v}
-              h.delete(row_number_column) if offset
+              h.delete(rn) if rn
               yield h
             end
+=begin
+        # Temporarily disable this optimization, as tiny_tds uses string keys
+        # if result.fields is called before result.each(:symbolize_keys=>true).
+        # See https://github.com/rails-sqlserver/tiny_tds/issues/57
           else
             each_opts[:symbolize_keys] = true
             if offset
               result.each(each_opts) do |r|
-                r.delete(row_number_column) if offset
+                r.delete(rn) if rn
                 yield r
               end
             else
-              result.each(each_opts, &block)
+              result.each(each_opts, &Proc.new)
             end
           end
+=end
         end
         self
       end
       
+      # Create a named prepared statement that is stored in the
+      # database (and connection) for reuse.
+      def prepare(type, name=nil, *values)
+        ps = to_prepared_statement(type, values)
+        ps.extend(PreparedStatementMethods)
+        if name
+          ps.prepared_statement_name = name
+          db.prepared_statements[name] = ps
+        end
+        ps
+      end
+      
       private
       
       # Properly escape the given string +v+.
-      def literal_string(v)
-        db.synchronize{|c| "N'#{c.escape(v)}'"}
+      def literal_string_append(sql, v)
+        sql << 'N' if mssql_unicode_strings
+        sql << "'" << db.synchronize{|c| c.escape(v)} << "'"
       end
     end
   end

data/lib/sequel/adapters/utils/emulate_offset_with_row_number.rb

@@ -0,0 +1,66 @@
+module Sequel
+  module EmulateOffsetWithRowNumber
+    # When a subselect that uses :offset is used in IN or NOT IN,
+    # use a nested subselect that only includes the first column
+    # instead of the ROW_NUMBER column added by the emulated offset support.
+    def complex_expression_sql_append(sql, op, args)
+      case op
+      when :IN, :"NOT IN"
+        ds = args.at(1)
+        if ds.is_a?(Sequel::Dataset) && ds.opts[:offset]
+          c = ds.opts[:select].first
+          case c
+          when Symbol
+            t, cl, a = split_symbol(c)
+            if a
+              c = SQL::Identifier.new(a)
+            elsif t
+              c = SQL::Identifier.new(cl)
+            end
+          when SQL::AliasedExpression
+            c = SQL::Identifier.new(c.aliaz)
+          when SQL::QualifiedIdentifier
+            c = SQL::Identifier.new(c.column)
+          end
+          super(sql, op, [args.at(0), ds.from_self.select(c)])
+        else
+          super
+        end
+      else
+        super
+      end
+    end
+
+    # Emulate OFFSET support with the ROW_NUMBER window function
+    # 
+    # The implementation is ugly, cloning the current dataset and modifying
+    # the clone to add a ROW_NUMBER window function (and some other things),
+    # then using the modified clone in a subselect which is selected from.
+    #
+    # If offset is used, an order must be provided, because the use of ROW_NUMBER
+    # requires an order.
+    def select_sql
+      return super unless o = @opts[:offset]
+      raise(Error, "#{db.database_type} requires an order be provided if using an offset") unless order = @opts[:order]
+      dsa1 = dataset_alias(1)
+      rn = row_number_column
+      sql = @opts[:append_sql] || ''
+      subselect_sql_append(sql, unlimited.
+        unordered.
+        select_append{ROW_NUMBER(:over, :order=>order){}.as(rn)}.
+        from_self(:alias=>dsa1).
+        limit(@opts[:limit]).
+        where(SQL::Identifier.new(rn) > o).
+        order(rn))
+      sql
+    end
+
+    private
+
+    # This emulation adds an extra row number column that should be
+    # eliminated.
+    def offset_returns_row_number_column?
+      true
+    end
+  end
+end

data/lib/sequel/adapters/utils/stored_procedures.rb

@@ -1,9 +1,6 @@
 module Sequel 
   class Dataset
     module StoredProcedureMethods
-      SQL_QUERY_TYPE = Hash.new{|h,k| h[k] = k}
-      SQL_QUERY_TYPE[:first] = SQL_QUERY_TYPE[:all] = :select
-      
       # The name of the stored procedure to call
       attr_accessor :sproc_name
       
@@ -44,14 +41,7 @@ module Sequel
       # ignored anyway).
       def sproc_type=(type)
         @sproc_type = type
-        meta_def("#{sql_query_type}_sql"){|*a| ''}
-      end
-      
-      private
-      
-      # The type of query (:select, :insert, :delete, :update).
-      def sql_query_type
-        SQL_QUERY_TYPE[@sproc_type]
+        @opts[:sql] = ''
       end
     end
   

data/lib/sequel/ast_transformer.rb

@@ -0,0 +1,190 @@
+module Sequel
+  # The +ASTTransformer+ class is designed to handle the abstract syntax trees
+  # that Sequel uses internally and produce modified copies of them.  By itself
+  # it only produces a straight copy.  It's designed to be subclassed and have
+  # subclasses returned modified copies of the specific nodes that need to
+  # be modified.
+  class ASTTransformer
+    # Return +obj+ or a potentially transformed version of it.
+    def transform(obj)
+      v(obj)
+    end
+
+    private
+
+    # Recursive version that handles all of Sequel's internal object types
+    # and produces copies of them.
+    def v(o)
+      case o
+      when Symbol, Numeric, String, Class, TrueClass, FalseClass, NilClass
+        o
+      when Array
+        o.map{|x| v(x)}
+      when Hash
+        h = {}
+        o.each{|k, val| h[v(k)] = v(val)}
+        h
+      when SQL::ComplexExpression
+        SQL::ComplexExpression.new(o.op, *v(o.args))
+      when SQL::Identifier
+        SQL::Identifier.new(v(o.value))
+      when SQL::QualifiedIdentifier
+        SQL::QualifiedIdentifier.new(v(o.table), v(o.column))
+      when SQL::OrderedExpression
+        SQL::OrderedExpression.new(v(o.expression), o.descending, :nulls=>o.nulls)
+      when SQL::AliasedExpression
+        SQL::AliasedExpression.new(v(o.expression), o.aliaz)
+      when SQL::CaseExpression
+        args = [v(o.conditions), v(o.default)]
+        args << v(o.expression) if o.expression?
+        SQL::CaseExpression.new(*args)
+      when SQL::Cast
+        SQL::Cast.new(v(o.expr), o.type)
+      when SQL::Function
+        SQL::Function.new(o.f, *v(o.args))
+      when SQL::Subscript
+        SQL::Subscript.new(v(o.f), v(o.sub))
+      when SQL::WindowFunction
+        SQL::WindowFunction.new(v(o.function), v(o.window))
+      when SQL::Window
+        opts = o.opts.dup
+        opts[:partition] = v(opts[:partition]) if opts[:partition]
+        opts[:order] = v(opts[:order]) if opts[:order]
+        SQL::Window.new(opts)
+      when SQL::PlaceholderLiteralString
+        args = if o.args.is_a?(Hash)
+          h = {}
+          o.args.each{|k,val| h[k] = v(val)}
+          h
+        else
+          v(o.args)
+        end
+        SQL::PlaceholderLiteralString.new(o.str, args, o.parens)
+      when SQL::JoinOnClause
+        SQL::JoinOnClause.new(v(o.on), o.join_type, v(o.table), v(o.table_alias))
+      when SQL::JoinUsingClause
+        SQL::JoinUsingClause.new(v(o.using), o.join_type, v(o.table), v(o.table_alias))
+      when SQL::JoinClause
+        SQL::JoinClause.new(o.join_type, v(o.table), v(o.table_alias))
+      else
+        o
+      end
+    end
+  end
+
+  # Handles qualifying existing datasets, so that unqualified columns
+  # in the dataset are qualified with a given table name.
+  class Qualifier < ASTTransformer
+    # Store the dataset to use as the basis for qualification, 
+    # and the table used to qualify unqualified columns. 
+    def initialize(ds, table)
+      @ds = ds
+      @table = table
+    end
+
+    private
+
+    # Turn <tt>SQL::Identifier</tt>s and symbols that aren't implicitly
+    # qualified into <tt>SQL::QualifiedIdentifier</tt>s.  For symbols that
+    # are not implicitly qualified by are implicitly aliased, return an
+    # <tt>SQL::AliasedExpression</tt>s with a qualified version of the symbol.
+    def v(o)
+      case o
+      when Symbol
+        t, column, aliaz = @ds.send(:split_symbol, o)
+        if t
+          o
+        elsif aliaz
+          SQL::AliasedExpression.new(SQL::QualifiedIdentifier.new(@table, SQL::Identifier.new(column)), aliaz)
+        else
+          SQL::QualifiedIdentifier.new(@table, o)
+        end
+      when SQL::Identifier
+        SQL::QualifiedIdentifier.new(@table, o)
+      when SQL::QualifiedIdentifier, SQL::JoinClause
+        # Return these directly, so we don't accidentally qualify symbols in them.
+        o
+      else
+        super
+      end
+    end
+  end
+
+  # +Unbinder+ is used to take a dataset filter and return a modified version
+  # that unbinds already bound values and returns a dataset with bound value
+  # placeholders and a hash of bind values.  You can then prepare the dataset
+  # and use the bound variables to execute it with the same values.
+  #
+  # This class only does a limited form of unbinding where the variable names
+  # and values can be associated unambiguously.  The only cases it handles
+  # are <tt>SQL::ComplexExpression<tt> with an operator in +UNBIND_OPS+, a
+  # first argument that's an instance of a member of +UNBIND_KEY_CLASSES+, and
+  # a second argument that's an instance of a member of +UNBIND_VALUE_CLASSES+.
+  #
+  # So it can handle cases like:
+  #
+  #   DB.filter(:a=>1).exclude(:b=>2).where{c > 3}
+  #
+  # But it cannot handle cases like:
+  #
+  #   DB.filter(:a + 1 < 0)
+  class Unbinder < ASTTransformer
+    # The <tt>SQL::ComplexExpression<tt> operates that will be considered
+    # for transformation.
+    UNBIND_OPS = [:'=', :'!=', :<, :>, :<=, :>=]
+
+    # The key classes (first argument of the ComplexExpression) that will
+    # considered for transformation.
+    UNBIND_KEY_CLASSES = [Symbol, SQL::Identifier, SQL::QualifiedIdentifier]
+
+    # The value classes (second argument of the ComplexExpression) that
+    # will be considered for transformation.
+    UNBIND_VALUE_CLASSES = [Numeric, String, Date, Time]
+
+    # The hash of bind variables that were extracted from the dataset filter.
+    attr_reader :binds
+
+    # Intialize an empty +binds+ hash.
+    def initialize
+      @binds = {}
+    end
+
+    private
+
+    # Create a suitable bound variable key for the object, which should be
+    # an instance of one of the +UNBIND_KEY_CLASSES+.
+    def bind_key(obj)
+      case obj
+      when Symbol, String
+        obj
+      when SQL::Identifier
+        bind_key(obj.value)
+      when SQL::QualifiedIdentifier
+        :"#{bind_key(obj.table)}.#{bind_key(obj.column)}"
+      else
+        raise Error, "unhandled object in Sequel::Unbinder#bind_key: #{obj}"
+      end
+    end
+
+    # Handle <tt>SQL::ComplexExpression</tt> instances with suitable ops
+    # and arguments, substituting the value with a bound variable placeholder
+    # and assigning it an entry in the +binds+ hash with a matching key.
+    def v(o)
+      if o.is_a?(SQL::ComplexExpression) && UNBIND_OPS.include?(o.op)
+        l, r = o.args
+        if UNBIND_KEY_CLASSES.any?{|c| l.is_a?(c)} && UNBIND_VALUE_CLASSES.any?{|c| r.is_a?(c)} && !r.is_a?(LiteralString)
+          key = bind_key(l)
+          if (old = binds[key]) && old != r
+            raise UnbindDuplicate, "two different values for #{key.inspect}: #{[r, old].inspect}" 
+          end
+          binds[key] = r
+          SQL::ComplexExpression.new(o.op, l, :"$#{key}")
+        else
+          super
+        end
+      else
+        super
+      end
+    end
+  end
+end

data/lib/sequel/connection_pool/threaded.rb

@@ -83,9 +83,10 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
       end
       yield conn
     rescue Sequel::DatabaseDisconnectError
-      @disconnection_proc.call(conn) if @disconnection_proc && conn
-      @allocated.delete(t)
+      oconn = conn
       conn = nil
+      @disconnection_proc.call(oconn) if @disconnection_proc && oconn
+      @allocated.delete(t)
       raise
     ensure
       sync{release(t)} if conn

data/lib/sequel/connection_pool.rb

@@ -53,7 +53,7 @@ class Sequel::ConnectionPool
     
     # Return a connection pool class based on the given options.
     def connection_pool_class(opts)
-      opts[:pool_class] || CONNECTION_POOL_MAP[[!!opts[:single_threaded], !!opts[:servers]]]
+      CONNECTION_POOL_MAP[opts[:pool_class]] || opts[:pool_class] || CONNECTION_POOL_MAP[[!!opts[:single_threaded], !!opts[:servers]]]
     end
   end
   extend ClassMethods

data/lib/sequel/core.rb

@@ -25,6 +25,7 @@
 module Sequel
   @convert_two_digit_years = true
   @datetime_class = Time
+  @empty_array_handle_nulls = true
   @virtual_row_instance_eval = true
   @require_thread = nil
   
@@ -54,6 +55,27 @@ module Sequel
     # days on +DateTime+).
     attr_accessor :datetime_class
 
+    # Sets whether or not to attempt to handle NULL values correctly when given
+    # an empty array.  By default:
+    #
+    #   DB[:a].filter(:b=>[])
+    #   # SELECT * FROM a WHERE (b != b)
+    #   DB[:a].exclude(:b=>[])
+    #   # SELECT * FROM a WHERE (b = b)
+    #
+    # However, some databases (e.g. MySQL) will perform very poorly
+    # with this type of query.  You can set this to false to get the
+    # following behavior:
+    #
+    #   DB[:a].filter(:b=>[])
+    #   # SELECT * FROM a WHERE 1 = 0
+    #   DB[:a].exclude(:b=>[])
+    #   # SELECT * FROM a WHERE 1 = 1
+    # 
+    # This may not handle NULLs correctly, but can be much faster on
+    # some databases.
+    attr_accessor :empty_array_handle_nulls
+
     # For backwards compatibility, has no effect.
     attr_accessor :virtual_row_instance_eval
     
@@ -188,7 +210,7 @@ module Sequel
   # This is used to ensure that the files loaded are from the same version of
   # Sequel as this file.
   def self.require(files, subdir=nil)
-    Array(files).each{|f| super("#{File.dirname(__FILE__)}/#{"#{subdir}/" if subdir}#{f}")}
+    Array(files).each{|f| super("#{File.dirname(__FILE__).untaint}/#{"#{subdir}/" if subdir}#{f}")}
   end
   
   # Set whether to set the single threaded mode for all databases by default. By default,
@@ -228,17 +250,58 @@ module Sequel
     end
   end
 
-  # Converts the given +string+ into a +Time+ object.
+  # Converts the given +string+ into a <tt>Sequel::SQLTime</tt> object.
   #
-  #   Sequel.string_to_datetime('10:20:30') # Time.parse('10:20:30')
+  #   v = Sequel.string_to_time('10:20:30') # Sequel::SQLTime.parse('10:20:30')
+  #   DB.literal(v) # => '10:20:30'
   def self.string_to_time(string)
     begin
-      Time.parse(string)
+      SQLTime.parse(string)
     rescue => e
       raise convert_exception_class(e, InvalidValue)
     end
   end
 
+  # Uses a transaction on all given databases with the given options. This:
+  #
+  #   Sequel.transaction([DB1, DB2, DB3]){...}
+  #
+  # is equivalent to:
+  #
+  #   DB1.transaction do
+  #     DB2.transaction do
+  #       DB3.transaction do
+  #         ...
+  #       end
+  #     end
+  #   end
+  #
+  # except that if Sequel::Rollback is raised by the block, the transaction is
+  # rolled back on all databases instead of just the last one.
+  #
+  # Note that this method cannot guarantee that all databases will commit or
+  # rollback.  For example, if DB3 commits but attempting to commit on DB2
+  # fails (maybe because foreign key checks are deferred), there is no way
+  # to uncommit the changes on DB3.  For that kind of support, you need to
+  # have two-phase commit/prepared transactions (which Sequel supports on
+  # some databases).
+  def self.transaction(dbs, opts={}, &block)
+    unless opts[:rollback]
+      rescue_rollback = true
+      opts = opts.merge(:rollback=>:reraise)
+    end
+    pr = dbs.reverse.inject(block){|bl, db| proc{db.transaction(opts, &bl)}}
+    if rescue_rollback
+      begin
+        pr.call
+      rescue Sequel::Rollback => e
+        nil
+      end
+    else
+      pr.call
+    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)}
@@ -292,7 +355,7 @@ module Sequel
 
   private_class_method :adapter_method, :def_adapter_method
   
-  require(%w"metaprogramming sql connection_pool exceptions dataset database timezones version")
+  require(%w"metaprogramming sql connection_pool exceptions dataset database timezones ast_transformer version")
   require('core_sql') if !defined?(::SEQUEL_NO_CORE_EXTENSIONS) && !ENV.has_key?('SEQUEL_NO_CORE_EXTENSIONS')
 
   # Add the database adapter class methods to Sequel via metaprogramming