sequel 3.37.0 → 3.38.0

data/lib/sequel/adapters/jdbc/jtds.rb

@@ -5,6 +5,17 @@ module Sequel
     # Database and Dataset instance methods for JTDS specific
     # support via JDBC.
     module JTDS
+      module DatabaseMethods
+        include Sequel::JDBC::MSSQL::DatabaseMethods
+
+        private
+
+        # Handle nil values by using setNull with the correct parameter type.
+        def set_ps_arg_nil(cps, i)
+          cps.setNull(i, cps.getParameterMetaData.getParameterType(i))
+        end
+      end
+
       # Dataset class for JTDS datasets accessed via JDBC.
       class Dataset < JDBC::Dataset
         include Sequel::MSSQL::DatasetMethods

data/lib/sequel/adapters/jdbc/postgresql.rb

@@ -15,18 +15,15 @@ module Sequel
         # Add the primary_keys and primary_key_sequences instance variables,
         # so we can get the correct return values for inserted rows.
         def self.extended(db)
-          db.instance_eval do
-            @primary_keys = {}
-            @primary_key_sequences = {}
-          end
+          db.send(:initialize_postgres_adapter)
         end
         
         private
         
         # Use setNull for nil arguments as the default behavior of setString
         # with nil doesn't appear to work correctly on PostgreSQL.
-        def set_ps_arg(cps, arg, i)
-          arg.nil? ? cps.setNull(i, JavaSQL::Types::NULL) : super
+        def set_ps_arg_nil(cps, i)
+          cps.setNull(i, JavaSQL::Types::NULL)
         end
 
         # Execute the connection configuration SQL queries on the connection.

data/lib/sequel/adapters/mock.rb

@@ -50,12 +50,17 @@ module Sequel
         'postgres' => lambda do |db|
           db.instance_eval do
             @server_version = 90103
-            @primary_keys = {}
-            @primary_key_sequences = {}
+            initialize_postgres_adapter
+          end
+          db.extend(Module.new do
+            def bound_variable_arg(arg, conn)
+              arg
+            end
+
             def primary_key(table)
               :id
             end
-          end
+          end)
         end
       }
 
@@ -127,6 +132,7 @@ module Sequel
       def initialize(opts={})
         super
         opts = @opts
+        @sqls = opts[:sqls] || []
         if mod_name = SHARED_ADAPTERS[opts[:host]]
           @shared_adapter = true
           require "sequel/adapters/shared/#{opts[:host]}"
@@ -141,7 +147,7 @@ module Sequel
         self.fetch = opts[:fetch]
         self.numrows = opts[:numrows]
         extend(opts[:extend]) if opts[:extend]
-        @sqls = opts[:sqls] || []
+        sqls
       end
 
       # Return a related Connection option connecting to the given shard.

data/lib/sequel/adapters/postgres.rb

@@ -1,5 +1,4 @@
 Sequel.require 'adapters/shared/postgres'
-Sequel.require 'adapters/utils/pg_types'
 
 begin 
   require 'pg' 
@@ -157,10 +156,6 @@ module Sequel
       
       set_adapter_scheme :postgres
 
-      # A hash of conversion procs, keyed by type integer (oid) and
-      # having callable values for the conversion proc for that type.
-      attr_reader :conversion_procs
-
       # Whether infinite timestamps should be converted on retrieval.  By default, no
       # conversion is done, so an error is raised if you attempt to retrieve an infinite
       # timestamp.  You can set this to :nil to convert to nil, :string to leave
@@ -172,8 +167,7 @@ module Sequel
       def initialize(*args)
         super
         @convert_infinite_timestamps = false
-        @primary_keys = {}
-        @primary_key_sequences = {}
+        initialize_postgres_adapter
       end
 
       # Convert given argument so that it can be used directly by pg.  Currently, pg doesn't
@@ -232,7 +226,6 @@ module Sequel
         conn.instance_variable_set(:@db, self)
         conn.instance_variable_set(:@prepared_statements, {}) if SEQUEL_POSTGRES_USES_PG
         connection_configuration_sqls.each{|sql| conn.execute(sql)}
-        @conversion_procs ||= get_conversion_procs(conn)
         conn
       end
       
@@ -354,12 +347,6 @@ module Sequel
         end
       end
 
-      # Reset the database's conversion procs, requires a server query if there
-      # any named types.
-      def reset_conversion_procs
-        synchronize{|conn| @conversion_procs = get_conversion_procs(conn)}
-      end
-
       # If convert_infinite_timestamps is true and the value is infinite, return an appropriate
       # value based on the convert_infinite_timestamps setting.
       def to_application_timestamp(value)
@@ -447,20 +434,6 @@ module Sequel
         end
       end
 
-      # Return the conversion procs hash to use for this database.
-      def get_conversion_procs(conn)
-        procs = PG_TYPES.dup
-        procs[1184] = procs[1114] = method(:to_application_timestamp)
-        unless (pgnt = PG_NAMED_TYPES).empty?
-          conn.execute("SELECT oid, typname FROM pg_type where typtype = 'b' AND typname IN ('#{pgnt.keys.map{|type| conn.escape_string(type.to_s)}.join("', '")}')") do |res|
-            res.ntuples.times do |i|
-              procs[res.getvalue(i, 0).to_i] ||= pgnt[res.getvalue(i, 1).untaint.to_sym]
-            end
-          end
-        end
-        procs
-      end
-
       # Return an appropriate value for the given infinite timestamp string.
       def infinite_timestamp_value(value)
         case convert_infinite_timestamps

data/lib/sequel/adapters/shared/mssql.rb

@@ -93,9 +93,17 @@ module Sequel
       def views(opts={})
         information_schema_tables('VIEW', opts)
       end
-
+      
       private
       
+      # Add dropping of the default constraint to the list of SQL queries.
+      # This is necessary before dropping the column or changing its type.
+      def add_drop_default_constraint_sql(sqls, table, column)
+        if constraint = default_constraint_name(table, column)
+          sqls << "ALTER TABLE #{quote_schema_table(table)} DROP CONSTRAINT #{constraint}"
+        end
+      end
+
       # MSSQL uses the IDENTITY(1,1) column for autoincrementing columns.
       def auto_increment_sql
         AUTO_INCREMENT
@@ -106,6 +114,10 @@ module Sequel
         case op[:op]
         when :add_column
           "ALTER TABLE #{quote_schema_table(table)} ADD #{column_definition_sql(op)}"
+        when :drop_column
+          sqls = []
+          add_drop_default_constraint_sql(sqls, table, op[:name])
+          sqls << super
         when :rename_column
           "sp_rename #{literal("#{quote_schema_table(table)}.#{quote_identifier(op[:name])}")}, #{literal(op[:new_name].to_s)}, 'COLUMN'"
         when :set_column_type
@@ -113,9 +125,7 @@ module Sequel
           if sch = schema(table)
             if cs = sch.each{|k, v| break v if k == op[:name]; nil}
               cs = cs.dup
-              if constraint = default_constraint_name(table, op[:name])
-                sqls << "ALTER TABLE #{quote_schema_table(table)} DROP CONSTRAINT #{constraint}"
-              end
+              add_drop_default_constraint_sql(sqls, table, op[:name])
               cs[:default] = cs[:ruby_default]
               op = cs.merge!(op)
               default = op.delete(:default)
@@ -176,15 +186,15 @@ module Sequel
       end
     
       # The name of the constraint for setting the default value on the table and column.
-      def default_constraint_name(table, column)
-        from(:sysobjects___c_obj).
-          join(:syscomments___com, :id=>:id).
-          join(:sysobjects___t_obj, :id=>:c_obj__parent_obj).
-          join(:sysconstraints___con, :constid=>:c_obj__id).
-          join(:syscolumns___col, :id=>:t_obj__id, :colid=>:colid).
-          where{{c_obj__uid=>user_id{}}}.
-          where(:c_obj__xtype=>'D', :t_obj__name=>table.to_s, :col__name=>column.to_s).
-          get(:c_obj__name)
+      # The SQL used to select default constraints utilizes MSSQL catalog views which were introduced in 2005.
+      # This method intentionally does not support MSSQL 2000.
+      def default_constraint_name(table, column_name)
+        if server_version >= 9000000
+          table_name = schema_and_table(table).compact.join('.')
+          self[:sys__default_constraints].
+            where{{:parent_object_id => object_id(table_name), col_name(:parent_object_id, :parent_column_id) => column_name.to_s}}.
+            get(:name)
+        end
       end
 
       # The SQL to drop an index for the table.

data/lib/sequel/adapters/shared/postgres.rb

@@ -1,3 +1,5 @@
+Sequel.require 'adapters/utils/pg_types'
+
 module Sequel
   # Top level module for holding all PostgreSQL-related modules and classes
   # for Sequel.  There are a few module level accessors that are added via
@@ -146,6 +148,13 @@ module Sequel
       end_sql
       ).strip.gsub(/\s+/, ' ').freeze
 
+      # The Sequel extensions that require reseting of the conversion procs.
+      RESET_PROCS_EXTENSIONS = [:pg_array, :pg_hstore, :pg_inet, :pg_interval, :pg_json, :pg_range].freeze
+
+      # A hash of conversion procs, keyed by type integer (oid) and
+      # having callable values for the conversion proc for that type.
+      attr_reader :conversion_procs
+
       # Commit an existing prepared transaction with the given transaction
       # identifier string.
       def commit_prepared_transaction(transaction_id)
@@ -250,6 +259,17 @@ module Sequel
         self << drop_trigger_sql(table, name, opts)
       end
 
+      # If any of the extensions that require reseting the conversion procs
+      # is loaded, reset them.  This is done here so that if you load
+      # multiple pg_* extensions in the same call, the conversion procs are
+      # only reset once instead of once for every extension.
+      def extension(*exts)
+        super
+        unless (RESET_PROCS_EXTENSIONS & exts).empty?
+          reset_conversion_procs
+        end
+      end
+
       # Return full foreign key information using the pg system tables, including
       # :name, :on_delete, :on_update, and :deferrable entries in the hashes.
       def foreign_key_list(table, opts={})
@@ -380,6 +400,12 @@ module Sequel
           end
         end
       end
+      
+      # Reset the database's conversion procs, requires a server query if there
+      # any named types.
+      def reset_conversion_procs
+        @conversion_procs = get_conversion_procs
+      end
 
       # Reset the primary key sequence for the given table, baseing it on the
       # maximum current value of the table's primary key.
@@ -643,6 +669,18 @@ module Sequel
         end
       end
 
+      # Return a hash with oid keys and callable values, used for converting types.
+      def get_conversion_procs
+        procs = PG_TYPES.dup
+        procs[1184] = procs[1114] = method(:to_application_timestamp)
+        unless (pgnt = PG_NAMED_TYPES).empty?
+          from(:pg_type).where(:typtype=>'b', :typname=>pgnt.keys.map{|t| t.to_s}).select_map([:oid, :typname]).each do |oid, name|
+            procs[oid.to_i] ||= pgnt[name.untaint.to_sym]
+          end
+        end
+        procs
+      end
+
       # PostgreSQL folds unquoted identifiers to lowercase, so it shouldn't need to upcase identifiers on input.
       def identifier_input_method_default
         nil
@@ -676,6 +714,13 @@ module Sequel
         "CREATE #{unique}INDEX#{' CONCURRENTLY' if index[:concurrently]} #{quote_identifier(index_name)} ON #{quote_schema_table(table_name)} #{"USING #{index_type} " if index_type}#{expr}#{filter}"
       end
 
+      # Setup datastructures shared by all postgres adapters.
+      def initialize_postgres_adapter
+        @primary_keys = {}
+        @primary_key_sequences = {}
+        reset_conversion_procs
+      end
+
       # Backbone of the tables and views support.
       def pg_class_relname(type, opts)
         ds = metadata_dataset.from(:pg_class).filter(:relkind=>type).select(:relname).exclude(SQL::StringExpression.like(:relname, SYSTEM_TABLE_REGEXP)).server(opts[:server]).join(:pg_namespace, :oid=>:relnamespace)
@@ -716,6 +761,7 @@ module Sequel
         m = output_identifier_meth(opts[:dataset])
         m2 = input_identifier_meth(opts[:dataset])
         ds = metadata_dataset.select(:pg_attribute__attname___name,
+            SQL::Cast.new(:pg_attribute__atttypid, :integer).as(:oid),
             SQL::Function.new(:format_type, :pg_type__oid, :pg_attribute__atttypmod).as(:db_type),
             SQL::Function.new(:pg_get_expr, :pg_attrdef__adbin, :pg_class__oid).as(:default),
             SQL::BooleanExpression.new(:NOT, :pg_attribute__attnotnull).as(:allow_null),

data/lib/sequel/adapters/swift.rb

@@ -1,11 +1,8 @@
-require 'swift'
-
 module Sequel
-  # Module holding the Swift support for Sequel.  Swift is a
-  # ruby front-end for dbic++, a fast database access library
-  # written in C++.
+  # Module holding the Swift DB support for Sequel.  Swift DB is a
+  # collection of drivers used in Swift ORM.
   #
-  # The Swift adapter currently supports PostgreSQL and MySQL:
+  # The Swift adapter currently supports PostgreSQL, MySQL and SQLite3
   #
   #   Sequel.connect('swift://user:password@host/database?db_type=postgres')
   #   Sequel.connect('swift://user:password@host/database?db_type=mysql')
@@ -60,7 +57,9 @@ module Sequel
       
       # Create an instance of swift_class for the given options.
       def connect(server)
-        setup_connection(swift_class.new(server_opts(server)))
+        opts = server_opts(server)
+        opts[:pass] = opts[:password]
+        setup_connection(swift_class.new(opts))
       end
       
       # Execute the given SQL, yielding a Swift::Result if a block is given.
@@ -70,7 +69,7 @@ module Sequel
             res = log_yield(sql){conn.execute(sql)}
             yield res if block_given?
             nil
-          rescue SwiftError => e
+          rescue ::Swift::Error => e
             raise_error(e)
           end
         end
@@ -81,8 +80,8 @@ module Sequel
       def execute_dui(sql, opts={})
         synchronize(opts[:server]) do |conn|
           begin
-            log_yield(sql){conn.execute(sql).rows}
-          rescue SwiftError => e
+            log_yield(sql){conn.execute(sql).affected_rows}
+          rescue ::Swift::Error => e
             raise_error(e)
           end
         end
@@ -94,7 +93,7 @@ module Sequel
         synchronize(opts[:server]) do |conn|
           begin
             log_yield(sql){conn.execute(sql).insert_id}
-          rescue SwiftError => e
+          rescue ::Swift::Error => e
             raise_error(e)
           end
         end
@@ -138,8 +137,17 @@ module Sequel
       # Set the columns and yield the hashes to the block.
       def fetch_rows(sql)
         execute(sql) do |res|
-          @columns = res.fields
-          res.each{|h| yield h}
+          col_map = {}
+          @columns = res.fields.map do |c|
+            col_map[c] = output_identifier(c)
+          end
+          res.each do |r|
+            h = {}
+            r.each do |k, v|
+              h[col_map[k]] = v.is_a?(StringIO) ? SQL::Blob.new(v.read) : v
+            end
+            yield h
+          end
         end
         self
       end

data/lib/sequel/adapters/swift/mysql.rb

@@ -1,3 +1,4 @@
+require 'swift/db/mysql'
 Sequel.require 'adapters/shared/mysql'
 
 module Sequel

data/lib/sequel/adapters/swift/postgres.rb

@@ -1,7 +1,8 @@
+require 'swift/db/postgres'
 Sequel.require 'adapters/shared/postgres'
 
 module Sequel
-  Postgres::CONVERTED_EXCEPTIONS << ::SwiftError
+  Postgres::CONVERTED_EXCEPTIONS << ::Swift::Error
   
   module Swift
     # Adapter, Database, and Dataset support for accessing a PostgreSQL
@@ -14,10 +15,7 @@ module Sequel
         # Add the primary_keys and primary_key_sequences instance variables,
         # so we can get the correct return values for inserted rows.
         def self.extended(db)
-          db.instance_eval do
-            @primary_keys = {}
-            @primary_key_sequences = {}
-          end
+          db.send(:initialize_postgres_adapter)
         end
         
         private
@@ -35,6 +33,7 @@ module Sequel
         # Extend the adapter with the Swift PostgreSQL AdapterMethods.
         def setup_connection(conn)
           conn = super(conn)
+          conn.native_bind_format = true
           connection_configuration_sqls.each{|sql| log_yield(sql){conn.execute(sql)}}
           conn
         end

data/lib/sequel/adapters/swift/sqlite.rb

@@ -1,3 +1,4 @@
+require 'swift/db/sqlite3'
 Sequel.require 'adapters/shared/sqlite'
 
 module Sequel
@@ -25,7 +26,7 @@ module Sequel
         
         # Use Swift's escape method for quoting.
         def literal_string_append(sql, s)
-          sql << db.synchronize{|c| c.escape(s)}
+          sql << APOS << db.synchronize{|c| c.escape(s)} << APOS
         end
       end
     end

data/lib/sequel/adapters/tinytds.rb

@@ -6,13 +6,25 @@ 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 :user option to the :username option.
       def connect(server)
         opts = server_opts(server)
         opts[:username] = opts[:user]
-        set_mssql_unicode_strings
-        TinyTds::Client.new(opts)
+        c = TinyTds::Client.new(opts)
+
+        if (ts = opts[:textsize])
+          sql = "SET TEXTSIZE #{typecast_value_integer(ts)}"
+          log_yield(sql){c.execute(sql)}
+        end
+      
+        c
       end
       
       # Execute the given +sql+ on the server.  If the :return option