sequel 4.21.0 → 4.22.0

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

@@ -1,5 +1,6 @@
 Sequel::JDBC.load_driver('com.foundationdb.sql.jdbc.Driver')
 Sequel.require 'adapters/shared/fdbsql'
+Sequel::Deprecation.deprecate 'The jdbc/fdbsql adapter is deprecated and will be removed in a future version of Sequel.'
 
 module Sequel
   Fdbsql::CONVERTED_EXCEPTIONS << NativeException

data/lib/sequel/adapters/mysql.rb

@@ -303,7 +303,7 @@ module Sequel
             type_proc = f.type == 1 && cast_tinyint_integer?(f) ? cps[2] : cps[f.type]
             [output_identifier(f.name), type_proc, i+=1]
           end
-          @columns = cols.map{|c| c.first}
+          @columns = cols.map(&:first)
           if opts[:split_multiple_result_sets]
             s = []
             yield_rows(r, cols){|h| s << h}
@@ -347,8 +347,10 @@ module Sequel
       end
       
       # Set the :type option to :select if it hasn't been set.
-      def execute(sql, opts=OPTS, &block)
-        super(sql, {:type=>:select}.merge(opts), &block)
+      def execute(sql, opts=OPTS)
+        opts = Hash[opts]
+        opts[:type] = :select
+        super
       end
       
       # Handle correct quoting of strings using ::MySQL.quote.

data/lib/sequel/adapters/mysql2.rb

@@ -188,8 +188,11 @@ module Sequel
       end
 
       # Set the :type option to :select if it hasn't been set.
-      def execute(sql, opts=OPTS, &block)
-        super(sql, {:type=>:select, :stream=>@opts[:stream]}.merge(opts), &block)
+      def execute(sql, opts=OPTS)
+        opts = Hash[opts]
+        opts[:type] = :select
+        opts[:stream] = @opts[:stream]
+        super
       end
 
       # Handle correct quoting of strings using ::Mysql2::Client#escape.

data/lib/sequel/adapters/odbc.rb

@@ -94,13 +94,13 @@ module Sequel
       def fetch_rows(sql)
         execute(sql) do |s|
           i = -1
-          cols = s.columns(true).map{|c| [output_identifier(c.name), i+=1]}
+          cols = s.columns(true).map{|c| [output_identifier(c.name), c.type, i+=1]}
           columns = cols.map{|c| c.at(0)}
           @columns = columns
           if rows = s.fetch_all
             rows.each do |row|
               hash = {}
-              cols.each{|n,j| hash[n] = convert_odbc_value(row[j])}
+              cols.each{|n,t,j| hash[n] = convert_odbc_value(row[j], t)}
               yield hash
             end
           end
@@ -110,7 +110,7 @@ module Sequel
       
       private
 
-      def convert_odbc_value(v)
+      def convert_odbc_value(v, t)
         # When fetching a result set, the Ruby ODBC driver converts all ODBC 
         # SQL types to an equivalent Ruby type; with the exception of
         # SQL_TYPE_DATE, SQL_TYPE_TIME and SQL_TYPE_TIMESTAMP.
@@ -125,7 +125,11 @@ module Sequel
         when ::ODBC::Date
           Date.new(v.year, v.month, v.day)
         else
-          v
+          if t == ::ODBC::SQL_BIT
+            v == 1
+          else
+            v
+          end
         end
       end
       

data/lib/sequel/adapters/openbase.rb

@@ -1,4 +1,5 @@
 require 'openbase'
+Sequel::Deprecation.deprecate 'The openbase adapter is deprecated and will be removed in a future version of Sequel.'
 
 module Sequel
   module OpenBase

data/lib/sequel/adapters/oracle.rb

@@ -15,7 +15,7 @@ module Sequel
       
       ORACLE_TYPES = {
         :blob=>lambda{|b| Sequel::SQL::Blob.new(b.read)},
-        :clob=>lambda{|b| b.read}
+        :clob=>lambda(&:read)
       }
 
       # Hash of conversion procs for this database.
@@ -348,52 +348,9 @@ module Sequel
         end
       end
       
-      # Oracle prepared statement uses a new prepared statement each time
-      # it is called, but it does use the bind arguments.
-      module BindArgumentMethods
-        include ArgumentMapper
+      BindArgumentMethods = prepared_statements_module(:bind, ArgumentMapper)
+      PreparedStatementMethods = prepared_statements_module(:prepare, BindArgumentMethods)
 
-        private
-        
-        # Run execute_select on the database with the given SQL and the stored
-        # bind arguments.
-        def execute(sql, opts=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=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=OPTS, &block)
-          super(prepared_sql, {:arguments=>bind_arguments}.merge(opts), &block)
-        end
-      end
-
-      module PreparedStatementMethods
-        include BindArgumentMethods
-          
-        private
-          
-        # Execute the stored prepared statement name and the stored bind
-        # arguments instead of the SQL given.
-        def execute(sql, opts=OPTS, &block)
-          super(prepared_statement_name, opts, &block)
-        end
-         
-        # Same as execute, explicit due to intricacies of alias and super.
-        def execute_dui(sql, opts=OPTS, &block)
-          super(prepared_statement_name, opts, &block)
-        end
-          
-        # Same as execute, explicit due to intricacies of alias and super.
-        def execute_insert(sql, opts=OPTS, &block)
-          super(prepared_statement_name, opts, &block)
-        end
-      end
-        
       # Execute the given type of statement with the hash of values.
       def call(type, bind_vars={}, *values, &block)
         ps = to_prepared_statement(type, values)

data/lib/sequel/adapters/postgres.rb

@@ -681,7 +681,7 @@ module Sequel
       # This is untested with the prepared statement/bound variable support,
       # and unlikely to work with either.
       def use_cursor(opts=OPTS)
-        clone(:cursor=>{:rows_per_fetch=>1000}.merge(opts))
+        clone(:cursor=>{:rows_per_fetch=>1000}.merge!(opts))
       end
 
       # Replace the WHERE clause with one that uses CURRENT OF with the given
@@ -732,47 +732,14 @@ module Sequel
           end
         end
 
-        # Allow use of bind arguments for PostgreSQL using the pg driver.
-        module BindArgumentMethods
-          include ArgumentMapper
-          include ::Sequel::Postgres::DatasetMethods::PreparedStatementMethods
-          
-          private
-          
-          # Execute the given SQL with the stored bind arguments.
-          def execute(sql, opts=OPTS, &block)
-            super(sql, {:arguments=>bind_arguments}.merge(opts), &block)
-          end
-          
-          # Same as execute, explicit due to intricacies of alias and super.
-          def execute_dui(sql, opts=OPTS, &block)
-            super(sql, {:arguments=>bind_arguments}.merge(opts), &block)
-          end
-        end
-        
-        # Allow use of server side prepared statements for PostgreSQL using the
-        # pg driver.
-        module PreparedStatementMethods
-          include BindArgumentMethods
+        BindArgumentMethods = prepared_statements_module(:bind, [ArgumentMapper, ::Sequel::Postgres::DatasetMethods::PreparedStatementMethods], %w'execute execute_dui')
 
+        PreparedStatementMethods = prepared_statements_module(:prepare, BindArgumentMethods, %w'execute execute_dui') do
           # Raise a more obvious error if you attempt to call a unnamed prepared statement.
           def call(*)
             raise Error, "Cannot call prepared statement without a name" if prepared_statement_name.nil?
             super
           end
-          
-          private
-          
-          # Execute the stored prepared statement name and the stored bind
-          # arguments instead of the SQL given.
-          def execute(sql, opts=OPTS, &block)
-            super(prepared_statement_name, opts, &block)
-          end
-          
-          # Same as execute, explicit due to intricacies of alias and super.
-          def execute_dui(sql, opts=OPTS, &block)
-            super(prepared_statement_name, opts, &block)
-          end
         end
         
         # Execute the given type of statement with the hash of values.

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

@@ -12,7 +12,7 @@ module Sequel
 
       # Doesn't work, due to security restrictions on MSysObjects
       #def tables
-      #  from(:MSysObjects).filter(:Type=>1, :Flags=>0).select_map(:Name).map{|x| x.to_sym}
+      #  from(:MSysObjects).filter(:Type=>1, :Flags=>0).select_map(:Name).map(&:to_sym)
       #end
       
       # Access doesn't support renaming tables from an SQL query,

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

@@ -265,9 +265,9 @@ module Sequel
       end
 
       STALE_STATEMENT_SQLSTATE = '0A50A'.freeze
-      NOT_NULL_CONSTRAINT_SQLSTATES = %w'23502'.freeze.each{|s| s.freeze}
-      FOREIGN_KEY_CONSTRAINT_SQLSTATES = %w'23503 23504'.freeze.each{|s| s.freeze}
-      UNIQUE_CONSTRAINT_SQLSTATES = %w'23501'.freeze.each{|s| s.freeze}
+      NOT_NULL_CONSTRAINT_SQLSTATES = %w'23502'.freeze.each(&:freeze)
+      FOREIGN_KEY_CONSTRAINT_SQLSTATES = %w'23503 23504'.freeze.each(&:freeze)
+      UNIQUE_CONSTRAINT_SQLSTATES = %w'23501'.freeze.each(&:freeze)
 
       # Given the SQLState, return the appropriate DatabaseError subclass.
       def database_specific_error_class_from_sqlstate(sqlstate)

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

@@ -466,7 +466,7 @@ module Sequel
           else
             schema_column_type(row[:db_type])
           end
-          row[:max_length] = row[:max_chars] if row[:type] == :string
+          row[:max_length] = row[:max_chars] if row[:type] == :string && row[:max_chars] >= 0
           [m.call(row.delete(:column)), row]
         end
       end

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

@@ -6,7 +6,7 @@ module Sequel
     # prepared statements and stored procedures.
     module PreparedStatements
       module DatabaseMethods
-        disconnect_errors = <<-END.split("\n").map{|l| l.strip}
+        disconnect_errors = <<-END.split("\n").map(&:strip)
         Commands out of sync; you can't run this command now
         Can't connect to local MySQL server through socket
         MySQL server has gone away
@@ -100,51 +100,19 @@ module Sequel
           end
         end
         
-        # Methods for MySQL prepared statements using the native driver.
-        module PreparedStatementMethods
-          include Sequel::Dataset::UnnumberedArgumentMapper
-          
-          # Raise a more obvious error if you attempt to call a unnamed prepared statement.
-          def call(*)
-            raise Error, "Cannot call prepared statement without a name" if prepared_statement_name.nil?
-            super
-          end
-          
-          private
-          
-          # Execute the prepared statement with the bind arguments instead of
-          # the given SQL.
-          def execute(sql, opts=OPTS, &block)
-            super(prepared_statement_name, {:arguments=>bind_arguments}.merge(opts), &block)
-          end
-          
-          # Same as execute, explicit due to intricacies of alias and super.
-          def execute_dui(sql, opts=OPTS, &block)
-            super(prepared_statement_name, {:arguments=>bind_arguments}.merge(opts), &block)
-          end
-          
-          # Same as execute, explicit due to intricacies of alias and super.
-          def execute_insert(sql, opts=OPTS, &block)
-            super(prepared_statement_name, {:arguments=>bind_arguments}.merge(opts), &block)
-          end
+        PreparedStatementMethods = Sequel::Dataset.send(:prepared_statements_module,
+          :prepare_bind,
+          Sequel::Dataset::UnnumberedArgumentMapper) do
+            # Raise a more obvious error if you attempt to call a unnamed prepared statement.
+            def call(*)
+              raise Error, "Cannot call prepared statement without a name" if prepared_statement_name.nil?
+              super
+            end
         end
         
-        # Methods for MySQL stored procedures using the native driver.
-        module StoredProcedureMethods
-          include Sequel::Dataset::StoredProcedureMethods
-          
-          private
-          
-          # Execute the database stored procedure with the stored arguments.
-          def execute(sql, opts=OPTS, &block)
-            super(@sproc_name, {:args=>@sproc_args, :sproc=>true}.merge(opts), &block)
-          end
-          
-          # Same as execute, explicit due to intricacies of alias and super.
-          def execute_dui(sql, opts=OPTS, &block)
-            super(@sproc_name, {:args=>@sproc_args, :sproc=>true}.merge(opts), &block)
-          end
-        end
+        StoredProcedureMethods = Sequel::Dataset.send(:prepared_statements_module,
+          "sql = @sproc_name; opts = Hash[opts]; opts[:args] = @sproc_args; opts[:sproc] = true",
+          Sequel::Dataset::StoredProcedureMethods, %w'execute execute_dui')
         
         # MySQL is different in that it supports prepared statements but not bound
         # variables outside of prepared statements.  The default implementation

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

@@ -474,8 +474,12 @@ module Sequel
       # If this dataset is associated with a sequence, return the most recently
       # inserted sequence value.
       def execute_insert(sql, opts=OPTS)
-        f = @opts[:from]
-        super(sql, {:table=>(f.first if f), :sequence=>@opts[:sequence]}.merge(opts))
+        opts = Hash[opts]
+        if f = @opts[:from]
+          opts[:table] = f.first
+        end
+        opts[:sequence] = @opts[:sequence]
+        super
       end
 
       # Use a colon for the timestamp offset, since Oracle appears to require it.

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

@@ -64,7 +64,7 @@ module Sequel
       # :where :: Create a partial exclusion constraint, which only affects
       #           a subset of table rows, value should be a filter expression.
       def exclude(elements, opts=OPTS)
-        constraints << {:type => :exclude, :elements => elements}.merge(opts)
+        constraints << {:type => :exclude, :elements => elements}.merge!(opts)
       end
     end
 
@@ -72,7 +72,7 @@ module Sequel
       # Adds an exclusion constraint to an existing table, see
       # CreateTableGenerator#exclude.
       def add_exclusion_constraint(elements, opts=OPTS)
-        @operations << {:op => :add_constraint, :type => :exclude, :elements => elements}.merge(opts)
+        @operations << {:op => :add_constraint, :type => :exclude, :elements => elements}.merge!(opts)
       end
 
       # Validate the constraint with the given name, which should have
@@ -667,7 +667,7 @@ module Sequel
         if search_path = @opts[:search_path]
           case search_path
           when String
-            search_path = search_path.split(",").map{|s| s.strip}
+            search_path = search_path.split(",").map(&:strip)
           when Array
             # nil
           else
@@ -706,7 +706,7 @@ module Sequel
       # Convert the hash of named conversion procs into a hash a oid conversion procs. 
       def convert_named_procs_to_procs(named_procs)
         h = {}
-        from(:pg_type).where(:typtype=>'b', :typname=>named_procs.keys.map{|t| t.to_s}).select_map([:oid, :typname]).each do |oid, name|
+        from(:pg_type).where(:typtype=>'b', :typname=>named_procs.keys.map(&:to_s)).select_map([:oid, :typname]).each do |oid, name|
           h[oid.to_i] = named_procs[name.untaint.to_sym]
         end
         h
@@ -1197,7 +1197,7 @@ module Sequel
       WINDOW = " WINDOW ".freeze
       SELECT_VALUES = "VALUES ".freeze
       EMPTY_STRING = ''.freeze
-      LOCK_MODES = ['ACCESS SHARE', 'ROW SHARE', 'ROW EXCLUSIVE', 'SHARE UPDATE EXCLUSIVE', 'SHARE', 'SHARE ROW EXCLUSIVE', 'EXCLUSIVE', 'ACCESS EXCLUSIVE'].each{|s| s.freeze}
+      LOCK_MODES = ['ACCESS SHARE', 'ROW SHARE', 'ROW EXCLUSIVE', 'SHARE UPDATE EXCLUSIVE', 'SHARE', 'SHARE ROW EXCLUSIVE', 'EXCLUSIVE', 'ACCESS EXCLUSIVE'].each(&:freeze)
 
       Dataset.def_sql_method(self, :delete, [['if server_version >= 90100', %w'with delete from using where returning'], ['else', %w'delete from using where returning']])
       Dataset.def_sql_method(self, :insert, [['if server_version >= 90100', %w'with insert into columns values returning'], ['else', %w'insert into columns values returning']])
@@ -1468,7 +1468,7 @@ module Sequel
       def _import(columns, values, opts=OPTS)
         if @opts[:returning]
           statements = multi_insert_sql(columns, values)
-          @db.transaction(opts.merge(:server=>@opts[:server])) do
+          @db.transaction(Hash[opts].merge!(:server=>@opts[:server])) do
             statements.map{|st| returning_fetch_rows(st)}
           end.first.map{|v| v.length == 1 ? v.values.first : v}
         elsif opts[:return] == :primary_key

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

@@ -416,7 +416,7 @@ module Sequel
            "DROP TABLE #{bt}"
         ]
         indexes(table).each do |name, h|
-          if (h[:columns].map{|x| x.to_s} - new_columns).empty?
+          if (h[:columns].map(&:to_s) - new_columns).empty?
             a << alter_table_sql(table, h.merge(:op=>:add_index, :name=>name))
           end
         end

data/lib/sequel/adapters/sqlite.rb

@@ -304,52 +304,9 @@ module Sequel
         end
       end
       
-      # SQLite prepared statement uses a new prepared statement each time
-      # it is called, but it does use the bind arguments.
-      module BindArgumentMethods
-        include ArgumentMapper
-        
-        private
-        
-        # Run execute_select on the database with the given SQL and the stored
-        # bind arguments.
-        def execute(sql, opts=OPTS, &block)
-          super(sql, {:arguments=>bind_arguments}.merge(opts), &block)
-        end
-        
-        # Same as execute, explicit due to intricacies of alias and super.
-        def execute_dui(sql, opts=OPTS, &block)
-          super(sql, {:arguments=>bind_arguments}.merge(opts), &block)
-        end
-        
-        # Same as execute, explicit due to intricacies of alias and super.
-        def execute_insert(sql, opts=OPTS, &block)
-          super(sql, {:arguments=>bind_arguments}.merge(opts), &block)
-        end
-      end
+      BindArgumentMethods = prepared_statements_module(:bind, ArgumentMapper)
+      PreparedStatementMethods = prepared_statements_module(:prepare, BindArgumentMethods)
 
-      module PreparedStatementMethods
-        include BindArgumentMethods
-          
-        private
-          
-        # Execute the stored prepared statement name and the stored bind
-        # arguments instead of the SQL given.
-        def execute(sql, opts=OPTS, &block)
-          super(prepared_statement_name, opts, &block)
-        end
-         
-        # Same as execute, explicit due to intricacies of alias and super.
-        def execute_dui(sql, opts=OPTS, &block)
-          super(prepared_statement_name, opts, &block)
-        end
-          
-        # Same as execute, explicit due to intricacies of alias and super.
-        def execute_insert(sql, opts=OPTS, &block)
-          super(prepared_statement_name, opts, &block)
-        end
-      end
-        
       # Execute the given type of statement with the hash of values.
       def call(type, bind_vars={}, *values, &block)
         ps = to_prepared_statement(type, values)
@@ -364,7 +321,7 @@ module Sequel
           cps = db.conversion_procs
           type_procs = result.types.map{|t| cps[base_type_name(t)]}
           cols = result.columns.map{|c| i+=1; [output_identifier(c), i, type_procs[i]]}
-          @columns = cols.map{|c| c.first}
+          @columns = cols.map(&:first)
           result.each do |values|
             row = {}
             cols.each do |name,id,type_proc|