sequel 3.21.0 → 3.36.0

data/lib/sequel/adapters/tinytds.rb

@@ -7,20 +7,14 @@ module Sequel
       include Sequel::MSSQL::DatabaseMethods
       set_adapter_scheme :tinytds
       
-      # Transfer the :host and :user options to the
-      # :dataserver and :username options.
+      # Transfer the :user option to the :username option.
       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 +26,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 +91,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.set_prepared_statement(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 << (mssql_unicode_strings ? UNICODE_STRING_START : APOS)
+        sql << db.synchronize{|c| c.escape(v)}.gsub(BACKSLASH_CRLF_RE, BACKSLASH_CRLF_REPLACE) << APOS
       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,194 @@
+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))
+      when SQL::Wrapper
+        SQL::Wrapper.new(v(o.value))
+      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
+        l = l.value if l.is_a?(Sequel::SQL::Wrapper)
+        r = r.value if r.is_a?(Sequel::SQL::Wrapper)
+        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/sharded_single.rb

@@ -26,6 +26,11 @@ class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
   def add_servers(servers)
     servers.each{|s| @servers[s] = s}
   end
+
+  # Yield all of the currently established connections
+  def all_connections
+    @conns.values.each{|c| yield c}
+  end
   
   # The connection for the given server.
   def conn(server=:default)
@@ -45,7 +50,7 @@ class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
   # This method simulates the ConnectionPool#hold API.
   def hold(server=:default)
     begin
-      server = @servers[server]
+      server = pick_server(server)
       yield(@conns[server] ||= make_new(server))
     rescue Sequel::DatabaseDisconnectError
       disconnect_server(server, &@disconnection_proc)
@@ -83,6 +88,11 @@ class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
       block.call(conn) if block
     end
   end
+
+  # If the server given is in the hash, return it, otherwise, return the default server.
+  def pick_server(server)
+    @servers[server]
+  end
   
   CONNECTION_POOL_MAP[[true, true]] = self
 end

data/lib/sequel/connection_pool/sharded_threaded.rb

@@ -45,6 +45,23 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
     @allocated[server]
   end
   
+  # Yield all of the available connections, and the ones currently allocated to
+  # this thread.  This will not yield connections currently allocated to other
+  # threads, as it is not safe to operate on them.  This holds the mutex while
+  # it is yielding all of the connections, which means that until
+  # the method's block returns, the pool is locked.
+  def all_connections
+    t = Thread.current
+    sync do
+      @allocated.values.each do |threads|
+        threads.each do |thread, conn|
+          yield conn if t == thread
+        end
+      end
+      @available_connections.values.each{|v| v.each{|c| yield c}}
+    end
+  end
+  
   # An array of connections opened but not currently used, for the given
   # server. Nonexistent servers will return nil. Treat this as read only, do
   # not modify the resulting object.
@@ -94,7 +111,7 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
   # connection can be acquired, a Sequel::PoolTimeout is 
   # raised.
   def hold(server=:default)
-    sync{server = @servers[server]}
+    server = pick_server(server)
     t = Thread.current
     if conn = owned_connection(t, server)
       return yield(conn)
@@ -190,6 +207,11 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
   def owned_connection(thread, server)
     sync{@allocated[server][thread]}
   end
+
+  # If the server given is in the hash, return it, otherwise, return the default server.
+  def pick_server(server)
+    sync{@servers[server]}
+  end
   
   # Releases the connection assigned to the supplied thread and server. If the
   # server or connection given is scheduled for disconnection, remove the
@@ -199,7 +221,11 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
     if @connections_to_remove.include?(conn)
       remove(thread, conn, server)
     else
-      available_connections(server) << allocated(server).delete(thread)
+      if @queue
+        available_connections(server).unshift(allocated(server).delete(thread))
+      else
+        available_connections(server) << allocated(server).delete(thread)
+      end
     end
   end
 

data/lib/sequel/connection_pool/single.rb

@@ -8,6 +8,11 @@ class Sequel::SingleConnectionPool < Sequel::ConnectionPool
     @conn ? 1 : 0
   end
   
+  # Yield the connection if one has been made.
+  def all_connections
+    yield @conn if @conn
+  end
+  
   # Disconnect the connection from the database.
   def disconnect(opts=nil, &block)
     return unless @conn