sequel 3.21.0 → 3.41.0

data/lib/sequel/adapters/tinytds.rb

@@ -6,21 +6,27 @@ module Sequel
     class Database < Sequel::Database
       include Sequel::MSSQL::DatabaseMethods
       set_adapter_scheme :tinytds
+
+      # Choose whether to use unicode strings on initialization
+      def initialize(*)
+        super
+        set_mssql_unicode_strings
+      end
       
-      # 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]
-        TinyTds::Client.new(opts)
-      end
+        c = TinyTds::Client.new(opts)
+
+        if (ts = opts[:textsize])
+          sql = "SET TEXTSIZE #{typecast_value_integer(ts)}"
+          log_yield(sql){c.execute(sql)}
+        end
       
-      # Return instance of Sequel::TinyTDS::Dataset with the given options.
-      def dataset(opts = nil)
-        TinyTDS::Dataset.new(self, opts)
+        c
       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 +38,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 +103,174 @@ module Sequel
         super
       end
 
-      # Close the TinyTds::Client object.
-      def disconnect_connection(c)
-        c.close
+      # tiny_tds uses TinyTds::Error as the base error class.
+      def database_error_classes
+        [TinyTds::Error]
+      end
+
+      # Return true if the :conn argument is present and not active.
+      def disconnect_error?(e, opts)
+        super || (opts[:conn] && !opts[:conn].active?)
+      end
+
+      # Dispose of any possible results of execution.
+      def log_connection_execute(conn, sql)
+        log_yield(sql){conn.execute(sql).each}
+      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,77 @@
+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]
+
+      order = @opts[:order] || default_offset_order
+      if order.nil? || order.empty?
+        raise(Error, "#{db.database_type} requires an order be provided if using an offset")
+      end
+
+      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
+
+    # The default order to use for datasets with offsets, if no order is defined.
+    # By default, orders by all of the columns in the dataset.
+    def default_offset_order
+      clone(:append_sql=>'').columns
+    end
+
+    # 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/pg_types.rb

@@ -0,0 +1,81 @@
+module Sequel
+  module Postgres
+    NAN             = 0.0/0.0
+    PLUS_INFINITY   = 1.0/0.0
+    MINUS_INFINITY  = -1.0/0.0
+    NAN_STR             = 'NaN'.freeze
+    PLUS_INFINITY_STR   = 'Infinity'.freeze
+    MINUS_INFINITY_STR  = '-Infinity'.freeze
+    TRUE_STR = 't'.freeze
+    DASH_STR = '-'.freeze
+    
+    TYPE_TRANSLATOR = tt = Class.new do
+      def boolean(s) s == TRUE_STR end
+      def integer(s) s.to_i end
+      def float(s) 
+        case s
+        when NAN_STR
+          NAN
+        when PLUS_INFINITY_STR
+          PLUS_INFINITY
+        when MINUS_INFINITY_STR
+          MINUS_INFINITY
+        else
+          s.to_f 
+        end
+      end
+      def date(s) ::Date.new(*s.split(DASH_STR).map{|x| x.to_i}) end
+      def bytea(str)
+        str = if str =~ /\A\\x/
+          # PostgreSQL 9.0+ bytea hex format
+          str[2..-1].gsub(/(..)/){|s| s.to_i(16).chr}
+        else
+          # Historical PostgreSQL bytea escape format
+          str.gsub(/\\(\\|'|[0-3][0-7][0-7])/) {|s|
+            if s.size == 2 then s[1,1] else s[1,3].oct.chr end
+          }
+        end
+        ::Sequel::SQL::Blob.new(str)
+      end
+    end.new
+
+    # Type OIDs for string types used by PostgreSQL.  These types don't
+    # have conversion procs associated with them (since the data is
+    # already in the form of a string).
+    STRING_TYPES = [18, 19, 25, 1042, 1043]
+
+    # Hash with type name strings/symbols and callable values for converting PostgreSQL types.
+    # Non-builtin types that don't have fixed numbers should use this to register
+    # conversion procs.
+    PG_NAMED_TYPES = {} unless defined?(PG_NAMED_TYPES)
+
+    # Hash with integer keys and callable values for converting PostgreSQL types.
+    PG_TYPES = {} unless defined?(PG_TYPES)
+
+    {
+      [16] => tt.method(:boolean),
+      [17] => tt.method(:bytea),
+      [20, 21, 23, 26] => tt.method(:integer),
+      [700, 701] => tt.method(:float),
+      [1700] => ::BigDecimal.method(:new),
+      [1083, 1266] => ::Sequel.method(:string_to_time),
+      [1184, 1114] => ::Sequel.method(:database_to_application_timestamp),
+    }.each do |k,v|
+      k.each{|n| PG_TYPES[n] = v}
+    end
+    
+    class << self
+      # As an optimization, Sequel sets the date style to ISO, so that PostgreSQL provides
+      # the date in a known format that Sequel can parse faster.  This can be turned off
+      # if you require a date style other than ISO.
+      attr_reader :use_iso_date_format
+    end
+
+    # Modify the type translator for the date type depending on the value given.
+    def self.use_iso_date_format=(v)
+      PG_TYPES[1082] = v ? TYPE_TRANSLATOR.method(:date) : Sequel.method(:string_to_date)
+      @use_iso_date_format = v
+    end
+    self.use_iso_date_format = true
+  end
+end 

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

@@ -0,0 +1,36 @@
+module Sequel::Database::SplitAlterTable
+  private
+
+  # Preprocess the array of operations.  If it looks like some operations depend
+  # on results of earlier operations and may require reloading the schema to
+  # work correctly, split those operations into separate lists, and between each
+  # list, remove the cached schema so that the later operations deal with the
+  # then current table schema.
+  def apply_alter_table(name, ops)
+    modified_columns = []
+    op_groups = [[]]
+    ops.each do |op|
+      case op[:op]
+      when :add_column, :set_column_type, :set_column_null, :set_column_default
+        if modified_columns.include?(op[:name])
+          op_groups << []
+        else
+          modified_columns << op[:name]
+        end
+      when :rename_column
+        if modified_columns.include?(op[:name]) || modified_columns.include?(op[:new_name])
+          op_groups << []
+        end
+        modified_columns << op[:name] unless modified_columns.include?(op[:name])
+        modified_columns << op[:new_name] unless modified_columns.include?(op[:new_name])
+      end
+      op_groups.last << op
+    end
+
+    op_groups.each do |ops|
+      next if ops.empty?
+      alter_table_sql_list(name, ops).each{|sql| execute_ddl(sql)}
+      remove_cached_schema(name)
+    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